Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.0

0.1.0 / src / engine / lanes_convert.lucb

# Generated by tools/lanes.py from its tables; edit those, not this file.
# Conversions between kinds: C casts and Base's checked conversions.

## Run `cast` (C's `(T)x`) or `convert` (Base's checked `T(x)`) from `source` lanes to
## the instruction's kind; the lowest faulting lane, or the lane count.
func conversion(w: Worker*, ins: Instruction, source: Kind) -> usize:
    if ins.op == .cast:
        match source:
            .f32:
                match ins.kind:
                    .f32: cast_f32_f32(w.f32s(ins.dst), w.f32s(ins.a))
                    .f64: cast_f32_f64(w.f64s(ins.dst), w.f32s(ins.a))
                    .i32: cast_f32_i32(w.i32s(ins.dst), w.f32s(ins.a))
                    .i64: cast_f32_i64(w.i64s(ins.dst), w.f32s(ins.a))
                    .u32: cast_f32_u32(w.u32s(ins.dst), w.f32s(ins.a))
                    .u64: cast_f32_u64(w.u64s(ins.dst), w.f32s(ins.a))
                    .mask: cast_f32_mask(w.masks(ins.dst), w.f32s(ins.a))
                    _: return w.n
            .f64:
                match ins.kind:
                    .f32: cast_f64_f32(w.f32s(ins.dst), w.f64s(ins.a))
                    .f64: cast_f64_f64(w.f64s(ins.dst), w.f64s(ins.a))
                    .i32: cast_f64_i32(w.i32s(ins.dst), w.f64s(ins.a))
                    .i64: cast_f64_i64(w.i64s(ins.dst), w.f64s(ins.a))
                    .u32: cast_f64_u32(w.u32s(ins.dst), w.f64s(ins.a))
                    .u64: cast_f64_u64(w.u64s(ins.dst), w.f64s(ins.a))
                    .mask: cast_f64_mask(w.masks(ins.dst), w.f64s(ins.a))
                    _: return w.n
            .i32:
                match ins.kind:
                    .f32: cast_i32_f32(w.f32s(ins.dst), w.i32s(ins.a))
                    .f64: cast_i32_f64(w.f64s(ins.dst), w.i32s(ins.a))
                    .i32: cast_i32_i32(w.i32s(ins.dst), w.i32s(ins.a))
                    .i64: cast_i32_i64(w.i64s(ins.dst), w.i32s(ins.a))
                    .u32: cast_i32_u32(w.u32s(ins.dst), w.i32s(ins.a))
                    .u64: cast_i32_u64(w.u64s(ins.dst), w.i32s(ins.a))
                    .mask: cast_i32_mask(w.masks(ins.dst), w.i32s(ins.a))
                    _: return w.n
            .i64:
                match ins.kind:
                    .f32: cast_i64_f32(w.f32s(ins.dst), w.i64s(ins.a))
                    .f64: cast_i64_f64(w.f64s(ins.dst), w.i64s(ins.a))
                    .i32: cast_i64_i32(w.i32s(ins.dst), w.i64s(ins.a))
                    .i64: cast_i64_i64(w.i64s(ins.dst), w.i64s(ins.a))
                    .u32: cast_i64_u32(w.u32s(ins.dst), w.i64s(ins.a))
                    .u64: cast_i64_u64(w.u64s(ins.dst), w.i64s(ins.a))
                    .mask: cast_i64_mask(w.masks(ins.dst), w.i64s(ins.a))
                    _: return w.n
            .u32:
                match ins.kind:
                    .f32: cast_u32_f32(w.f32s(ins.dst), w.u32s(ins.a))
                    .f64: cast_u32_f64(w.f64s(ins.dst), w.u32s(ins.a))
                    .i32: cast_u32_i32(w.i32s(ins.dst), w.u32s(ins.a))
                    .i64: cast_u32_i64(w.i64s(ins.dst), w.u32s(ins.a))
                    .u32: cast_u32_u32(w.u32s(ins.dst), w.u32s(ins.a))
                    .u64: cast_u32_u64(w.u64s(ins.dst), w.u32s(ins.a))
                    .mask: cast_u32_mask(w.masks(ins.dst), w.u32s(ins.a))
                    _: return w.n
            .u64:
                match ins.kind:
                    .f32: cast_u64_f32(w.f32s(ins.dst), w.u64s(ins.a))
                    .f64: cast_u64_f64(w.f64s(ins.dst), w.u64s(ins.a))
                    .i32: cast_u64_i32(w.i32s(ins.dst), w.u64s(ins.a))
                    .i64: cast_u64_i64(w.i64s(ins.dst), w.u64s(ins.a))
                    .u32: cast_u64_u32(w.u32s(ins.dst), w.u64s(ins.a))
                    .u64: cast_u64_u64(w.u64s(ins.dst), w.u64s(ins.a))
                    .mask: cast_u64_mask(w.masks(ins.dst), w.u64s(ins.a))
                    _: return w.n
            .mask:
                match ins.kind:
                    .f32: cast_mask_f32(w.f32s(ins.dst), w.masks(ins.a))
                    .f64: cast_mask_f64(w.f64s(ins.dst), w.masks(ins.a))
                    .i32: cast_mask_i32(w.i32s(ins.dst), w.masks(ins.a))
                    .i64: cast_mask_i64(w.i64s(ins.dst), w.masks(ins.a))
                    .u32: cast_mask_u32(w.u32s(ins.dst), w.masks(ins.a))
                    .u64: cast_mask_u64(w.u64s(ins.dst), w.masks(ins.a))
                    .mask: cast_mask_mask(w.masks(ins.dst), w.masks(ins.a))
                    _: return w.n
            _: return w.n
        return w.n
    match source:
        .f32:
            match ins.kind:
                .f32: convert_f32_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: convert_f32_f64(w.f64s(ins.dst), w.f32s(ins.a))
                .i32: return convert_f32_i32(w.i32s(ins.dst), w.f32s(ins.a), w.on())
                .i64: return convert_f32_i64(w.i64s(ins.dst), w.f32s(ins.a), w.on())
                .u32: return convert_f32_u32(w.u32s(ins.dst), w.f32s(ins.a), w.on())
                .u64: return convert_f32_u64(w.u64s(ins.dst), w.f32s(ins.a), w.on())
                _: return w.n
        .f64:
            match ins.kind:
                .f32: convert_f64_f32(w.f32s(ins.dst), w.f64s(ins.a))
                .f64: convert_f64_f64(w.f64s(ins.dst), w.f64s(ins.a))
                .i32: return convert_f64_i32(w.i32s(ins.dst), w.f64s(ins.a), w.on())
                .i64: return convert_f64_i64(w.i64s(ins.dst), w.f64s(ins.a), w.on())
                .u32: return convert_f64_u32(w.u32s(ins.dst), w.f64s(ins.a), w.on())
                .u64: return convert_f64_u64(w.u64s(ins.dst), w.f64s(ins.a), w.on())
                _: return w.n
        .i32:
            match ins.kind:
                .f32: convert_i32_f32(w.f32s(ins.dst), w.i32s(ins.a))
                .f64: convert_i32_f64(w.f64s(ins.dst), w.i32s(ins.a))
                .i32: convert_i32_i32(w.i32s(ins.dst), w.i32s(ins.a))
                .i64: convert_i32_i64(w.i64s(ins.dst), w.i32s(ins.a))
                .u32: return convert_i32_u32(w.u32s(ins.dst), w.i32s(ins.a), w.on())
                .u64: return convert_i32_u64(w.u64s(ins.dst), w.i32s(ins.a), w.on())
                _: return w.n
        .i64:
            match ins.kind:
                .f32: convert_i64_f32(w.f32s(ins.dst), w.i64s(ins.a))
                .f64: convert_i64_f64(w.f64s(ins.dst), w.i64s(ins.a))
                .i32: return convert_i64_i32(w.i32s(ins.dst), w.i64s(ins.a), w.on())
                .i64: convert_i64_i64(w.i64s(ins.dst), w.i64s(ins.a))
                .u32: return convert_i64_u32(w.u32s(ins.dst), w.i64s(ins.a), w.on())
                .u64: return convert_i64_u64(w.u64s(ins.dst), w.i64s(ins.a), w.on())
                _: return w.n
        .u32:
            match ins.kind:
                .f32: convert_u32_f32(w.f32s(ins.dst), w.u32s(ins.a))
                .f64: convert_u32_f64(w.f64s(ins.dst), w.u32s(ins.a))
                .i32: return convert_u32_i32(w.i32s(ins.dst), w.u32s(ins.a), w.on())
                .i64: convert_u32_i64(w.i64s(ins.dst), w.u32s(ins.a))
                .u32: convert_u32_u32(w.u32s(ins.dst), w.u32s(ins.a))
                .u64: convert_u32_u64(w.u64s(ins.dst), w.u32s(ins.a))
                _: return w.n
        .u64:
            match ins.kind:
                .f32: convert_u64_f32(w.f32s(ins.dst), w.u64s(ins.a))
                .f64: convert_u64_f64(w.f64s(ins.dst), w.u64s(ins.a))
                .i32: return convert_u64_i32(w.i32s(ins.dst), w.u64s(ins.a), w.on())
                .i64: return convert_u64_i64(w.i64s(ins.dst), w.u64s(ins.a), w.on())
                .u32: return convert_u64_u32(w.u32s(ins.dst), w.u64s(ins.a), w.on())
                .u64: convert_u64_u64(w.u64s(ins.dst), w.u64s(ins.a))
                _: return w.n
        _: return w.n
    return w.n

func cast_f32_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_f32_f64(d: f64[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_f32_i32(d: i32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_f32_i64(d: i64[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_f32_u32(d: u32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_f32_u64(d: u64[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_f32_mask(d: u8[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != 0.0)

func cast_f64_f32(d: f32[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_f64_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_f64_i32(d: i32[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_f64_i64(d: i64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_f64_u32(d: u32[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_f64_u64(d: u64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_f64_mask(d: u8[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != 0.0)

func cast_i32_f32(d: f32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_i32_f64(d: f64[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_i32_i32(d: i32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_i32_i64(d: i64[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_i32_u32(d: u32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_i32_u64(d: u64[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_i32_mask(d: u8[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != 0)

func cast_i64_f32(d: f32[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_i64_f64(d: f64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_i64_i32(d: i32[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_i64_i64(d: i64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_i64_u32(d: u32[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_i64_u64(d: u64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_i64_mask(d: u8[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != 0)

func cast_u32_f32(d: f32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_u32_f64(d: f64[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_u32_i32(d: i32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_u32_i64(d: i64[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_u32_u32(d: u32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_u32_u64(d: u64[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_u32_mask(d: u8[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != 0)

func cast_u64_f32(d: f32[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_u64_f64(d: f64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_u64_i32(d: i32[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_u64_i64(d: i64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_u64_u32(d: u32[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_u64_u64(d: u64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_u64_mask(d: u8[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != 0)

func cast_mask_f32(d: f32[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func cast_mask_f64(d: f64[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func cast_mask_i32(d: i32[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func cast_mask_i64(d: i64[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func cast_mask_u32(d: u32[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func cast_mask_u64(d: u64[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func cast_mask_mask(d: u8[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i]

func convert_f32_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func convert_f32_f64(d: f64[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func convert_f32_i32(d: i32[], a: const f32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= -2147483648.0 and a[i] < 2147483648.0:
            d[i] = (i32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f32_i64(d: i64[], a: const f32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= -9223372036854775808.0 and a[i] < 9223372036854775808.0:
            d[i] = (i64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f32_u32(d: u32[], a: const f32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] > -1.0 and a[i] < 4294967296.0:
            d[i] = (u32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f32_u64(d: u64[], a: const f32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] > -1.0 and a[i] < 18446744073709551616.0:
            d[i] = (u64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f64_f32(d: f32[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func convert_f64_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func convert_f64_i32(d: i32[], a: const f64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] > -2147483649.0 and a[i] < 2147483648.0:
            d[i] = (i32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f64_i64(d: i64[], a: const f64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= -9223372036854775808.0 and a[i] < 9223372036854775808.0:
            d[i] = (i64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f64_u32(d: u32[], a: const f64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] > -1.0 and a[i] < 4294967296.0:
            d[i] = (u32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_f64_u64(d: u64[], a: const f64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] > -1.0 and a[i] < 18446744073709551616.0:
            d[i] = (u64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_i32_f32(d: f32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func convert_i32_f64(d: f64[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func convert_i32_i32(d: i32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i32)a[i]

func convert_i32_i64(d: i64[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func convert_i32_u32(d: u32[], a: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= 0:
            d[i] = (u32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_i32_u64(d: u64[], a: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= 0:
            d[i] = (u64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_i64_f32(d: f32[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func convert_i64_f64(d: f64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func convert_i64_i32(d: i32[], a: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= (-2147483648) and a[i] <= 2147483647:
            d[i] = (i32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_i64_i64(d: i64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func convert_i64_u32(d: u32[], a: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= 0 and a[i] <= 4294967295:
            d[i] = (u32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_i64_u64(d: u64[], a: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] >= 0:
            d[i] = (u64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_u32_f32(d: f32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func convert_u32_f64(d: f64[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func convert_u32_i32(d: i32[], a: const u32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] <= 2147483647:
            d[i] = (i32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_u32_i64(d: i64[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (i64)a[i]

func convert_u32_u32(d: u32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u32)a[i]

func convert_u32_u64(d: u64[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]

func convert_u64_f32(d: f32[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f32)a[i]

func convert_u64_f64(d: f64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (f64)a[i]

func convert_u64_i32(d: i32[], a: const u64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] <= 2147483647:
            d[i] = (i32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_u64_i64(d: i64[], a: const u64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] <= 9223372036854775807:
            d[i] = (i64)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_u64_u32(d: u32[], a: const u64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] <= 4294967295:
            d[i] = (u32)a[i]
        else:
            if on.at(i): return i
            d[i] = 0
    return d.length

func convert_u64_u64(d: u64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u64)a[i]