Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.1

0.1.1 / src / engine / lanes_binary.lucb

# Generated by tools/lanes.py from its tables; edit those, not this file.
# Binary lane operations: d = a op b, every operand of the instruction's kind.

## Run a binary instruction; the lowest faulting lane, or the lane count.
func binary(w: Worker*, ins: Instruction) -> usize:
    match ins.op:
        .add:
            match ins.kind:
                .f32: add_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: add_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: return add_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return add_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return add_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return add_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .sub:
            match ins.kind:
                .f32: sub_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: sub_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: return sub_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return sub_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return sub_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return sub_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .mul:
            match ins.kind:
                .f32: mul_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: mul_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: return mul_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return mul_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return mul_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return mul_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .div:
            match ins.kind:
                .f32: div_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: div_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                _: return w.n
        .wadd:
            match ins.kind:
                .i32: wadd_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: wadd_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: wadd_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: wadd_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .wsub:
            match ins.kind:
                .i32: wsub_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: wsub_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: wsub_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: wsub_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .wmul:
            match ins.kind:
                .i32: wmul_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: wmul_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: wmul_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: wmul_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .sadd:
            match ins.kind:
                .i32: sadd_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: sadd_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: sadd_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: sadd_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .ssub:
            match ins.kind:
                .i32: ssub_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: ssub_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: ssub_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: ssub_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .smul:
            match ins.kind:
                .i32: smul_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: smul_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: smul_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: smul_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .idiv:
            match ins.kind:
                .i32: return idiv_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return idiv_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return idiv_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return idiv_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .rem:
            match ins.kind:
                .i32: return rem_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return rem_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return rem_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return rem_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .min:
            match ins.kind:
                .f32: min_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: min_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: min_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: min_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: min_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: min_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .max:
            match ins.kind:
                .f32: max_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: max_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: max_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: max_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: max_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: max_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .band:
            match ins.kind:
                .i32: band_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: band_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: band_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: band_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                .mask: band_mask(w.masks(ins.dst), w.masks(ins.a), w.masks(ins.b))
                _: return w.n
        .bor:
            match ins.kind:
                .i32: bor_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: bor_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: bor_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: bor_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                .mask: bor_mask(w.masks(ins.dst), w.masks(ins.a), w.masks(ins.b))
                _: return w.n
        .bxor:
            match ins.kind:
                .i32: bxor_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: bxor_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: bxor_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: bxor_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                .mask: bxor_mask(w.masks(ins.dst), w.masks(ins.a), w.masks(ins.b))
                _: return w.n
        .shl:
            match ins.kind:
                .i32: return shl_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return shl_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return shl_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return shl_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .shr:
            match ins.kind:
                .i32: return shr_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.on())
                .i64: return shr_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.on())
                .u32: return shr_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.on())
                .u64: return shr_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.on())
                _: return w.n
        .pow:
            match ins.kind:
                .f32: pow_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: pow_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                _: return w.n
        .atan2:
            match ins.kind:
                .f32: atan2_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: atan2_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                _: return w.n
        .fmod:
            match ins.kind:
                .f32: fmod_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: fmod_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                _: return w.n
        .hypot:
            match ins.kind:
                .f32: hypot_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: hypot_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                _: return w.n
        _: return w.n
    return w.n

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

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

func add_i32(d: i32[], a: const i32[], b: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] +? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] +% b[i]
    return d.length

func add_i64(d: i64[], a: const i64[], b: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] +? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] +% b[i]
    return d.length

func add_u32(d: u32[], a: const u32[], b: const u32[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] +? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] +% b[i]
    return d.length

func add_u64(d: u64[], a: const u64[], b: const u64[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] +? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] +% b[i]
    return d.length

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

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

func sub_i32(d: i32[], a: const i32[], b: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] -? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] -% b[i]
    return d.length

func sub_i64(d: i64[], a: const i64[], b: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] -? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] -% b[i]
    return d.length

func sub_u32(d: u32[], a: const u32[], b: const u32[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] -? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] -% b[i]
    return d.length

func sub_u64(d: u64[], a: const u64[], b: const u64[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] -? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] -% b[i]
    return d.length

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

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

func mul_i32(d: i32[], a: const i32[], b: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] *? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] *% b[i]
    return d.length

func mul_i64(d: i64[], a: const i64[], b: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] *? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] *% b[i]
    return d.length

func mul_u32(d: u32[], a: const u32[], b: const u32[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] *? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] *% b[i]
    return d.length

func mul_u64(d: u64[], a: const u64[], b: const u64[], on: Active) -> usize:
    for i in 0..<d.length:
        if let value = a[i] *? b[i]:
            d[i] = value
        else:
            if on.at(i): return i
            d[i] = a[i] *% b[i]
    return d.length

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

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

func wadd_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +% b[i]

func wadd_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +% b[i]

func wadd_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +% b[i]

func wadd_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +% b[i]

func wsub_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -% b[i]

func wsub_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -% b[i]

func wsub_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -% b[i]

func wsub_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -% b[i]

func wmul_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *% b[i]

func wmul_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *% b[i]

func wmul_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *% b[i]

func wmul_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *% b[i]

func sadd_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +| b[i]

func sadd_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +| b[i]

func sadd_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +| b[i]

func sadd_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] +| b[i]

func ssub_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -| b[i]

func ssub_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -| b[i]

func ssub_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -| b[i]

func ssub_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] -| b[i]

func smul_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *| b[i]

func smul_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *| b[i]

func smul_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *| b[i]

func smul_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] *| b[i]

func idiv_i32(d: i32[], a: const i32[], b: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if b[i] == 0 or (b[i] == -1 and a[i] == (-2147483648)):
            if on.at(i): return i
            d[i] = 0
        else:
            d[i] = a[i] // b[i]
    return d.length

func idiv_i64(d: i64[], a: const i64[], b: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if b[i] == 0 or (b[i] == -1 and a[i] == (-9223372036854775808)):
            if on.at(i): return i
            d[i] = 0
        else:
            d[i] = a[i] // b[i]
    return d.length

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

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

func rem_i32(d: i32[], a: const i32[], b: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if b[i] == 0 or (b[i] == -1 and a[i] == (-2147483648)):
            if on.at(i): return i
            d[i] = 0
        else:
            d[i] = a[i] % b[i]
    return d.length

func rem_i64(d: i64[], a: const i64[], b: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if b[i] == 0 or (b[i] == -1 and a[i] == (-9223372036854775808)):
            if on.at(i): return i
            d[i] = 0
        else:
            d[i] = a[i] % b[i]
    return d.length

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

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

func min_f32(d: f32[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math32.min(a[i], b[i])

func min_f64(d: f64[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math.min(a[i], b[i])

func min_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] < b[i] else b[i]

func min_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] < b[i] else b[i]

func min_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] < b[i] else b[i]

func min_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] < b[i] else b[i]

func max_f32(d: f32[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math32.max(a[i], b[i])

func max_f64(d: f64[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math.max(a[i], b[i])

func max_i32(d: i32[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] > b[i] else b[i]

func max_i64(d: i64[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] > b[i] else b[i]

func max_u32(d: u32[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] > b[i] else b[i]

func max_u64(d: u64[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = a[i] if a[i] > b[i] else b[i]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func pow_f32(d: f32[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math32.pow(a[i], b[i])

func pow_f64(d: f64[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math.pow(a[i], b[i])

func atan2_f32(d: f32[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math32.atan2(a[i], b[i])

func atan2_f64(d: f64[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math.atan2(a[i], b[i])

func fmod_f32(d: f32[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math32.mod(a[i], b[i])

func fmod_f64(d: f64[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math.mod(a[i], b[i])

func hypot_f32(d: f32[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math32.hypot(a[i], b[i])

func hypot_f64(d: f64[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = math.hypot(a[i], b[i])