@aptre/v86 0.5.0

package/src/rust/cpu/arith.rs

@@ -0,0 +1,1207 @@
+use crate::cpu::cpu::*;
+use crate::cpu::global_pointers::*;
+use crate::cpu::memory;
+use crate::cpu::misc_instr::{getaf, getcf, getzf};
+
+fn int_log2(x: i32) -> i32 { 31 - x.leading_zeros() as i32 }
+
+fn opsize_to_mask(op_size: i32) -> i32 {
+    dbg_assert!(op_size == OPSIZE_8 || op_size == OPSIZE_16 || op_size == OPSIZE_32);
+    (2 << op_size) - 1
+}
+
+unsafe fn add(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let res = (dest_operand + source_operand) & opsize_to_mask(op_size);
+    *last_op1 = dest_operand;
+    *last_result = res;
+    *last_op_size = op_size;
+    *flags_changed = FLAGS_ALL;
+    return res;
+}
+unsafe fn adc(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let cf = getcf() as i32;
+    let res = (dest_operand + source_operand + cf) & opsize_to_mask(op_size);
+    *last_op1 = dest_operand;
+    *last_result = res;
+    *last_op_size = op_size;
+    *flags_changed = FLAGS_ALL & !FLAG_CARRY & !FLAG_ADJUST & !FLAG_OVERFLOW;
+    *flags = *flags & !FLAG_CARRY & !FLAG_ADJUST & !FLAG_OVERFLOW
+        | (dest_operand ^ ((dest_operand ^ source_operand) & (source_operand ^ res))) >> op_size
+            & FLAG_CARRY
+        | (dest_operand ^ source_operand ^ res) & FLAG_ADJUST
+        | ((source_operand ^ res) & (dest_operand ^ res)) >> op_size << 11 & FLAG_OVERFLOW;
+    return res;
+}
+unsafe fn sub(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let res = (dest_operand - source_operand) & opsize_to_mask(op_size);
+    *last_op1 = dest_operand;
+    *last_result = res;
+    *last_op_size = op_size;
+    *flags_changed = FLAGS_ALL | FLAG_SUB;
+    return res;
+}
+unsafe fn sbb(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let cf = getcf() as i32;
+    let res = (dest_operand - source_operand - cf) & opsize_to_mask(op_size);
+    *last_op1 = dest_operand;
+    *last_result = res;
+    *last_op_size = op_size;
+    *flags_changed = FLAGS_ALL & !FLAG_CARRY & !FLAG_ADJUST & !FLAG_OVERFLOW | FLAG_SUB;
+    *flags = *flags & !FLAG_CARRY & !FLAG_ADJUST & !FLAG_OVERFLOW
+        | (res ^ ((res ^ source_operand) & (source_operand ^ dest_operand))) >> op_size
+            & FLAG_CARRY
+        | (dest_operand ^ source_operand ^ res) & FLAG_ADJUST
+        | ((source_operand ^ dest_operand) & (res ^ dest_operand)) >> op_size << 11 & FLAG_OVERFLOW;
+    return res;
+}
+pub unsafe fn add8(x: i32, y: i32) -> i32 {
+    dbg_assert!(x >= 0 && x < 0x100);
+    dbg_assert!(y >= 0 && y < 0x100);
+    return add(x, y, OPSIZE_8);
+}
+#[no_mangle]
+pub unsafe fn add16(x: i32, y: i32) -> i32 {
+    dbg_assert!(x >= 0 && x < 0x10000);
+    dbg_assert!(y >= 0 && y < 0x10000);
+    return add(x, y, OPSIZE_16);
+}
+pub unsafe fn add32(x: i32, y: i32) -> i32 { return add(x, y, OPSIZE_32); }
+pub unsafe fn sub8(x: i32, y: i32) -> i32 { return sub(x, y, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn sub16(x: i32, y: i32) -> i32 { return sub(x, y, OPSIZE_16); }
+pub unsafe fn sub32(x: i32, y: i32) -> i32 { return sub(x, y, OPSIZE_32); }
+#[no_mangle]
+pub unsafe fn adc8(x: i32, y: i32) -> i32 { return adc(x, y, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn adc16(x: i32, y: i32) -> i32 { return adc(x, y, OPSIZE_16); }
+pub unsafe fn adc32(x: i32, y: i32) -> i32 { return adc(x, y, OPSIZE_32); }
+#[no_mangle]
+pub unsafe fn sbb8(x: i32, y: i32) -> i32 { return sbb(x, y, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn sbb16(x: i32, y: i32) -> i32 { return sbb(x, y, OPSIZE_16); }
+pub unsafe fn sbb32(x: i32, y: i32) -> i32 { return sbb(x, y, OPSIZE_32); }
+pub unsafe fn cmp8(x: i32, y: i32) {
+    dbg_assert!(x >= 0 && x < 0x100);
+    dbg_assert!(y >= 0 && y < 0x100);
+    sub(x, y, OPSIZE_8);
+}
+pub unsafe fn cmp16(x: i32, y: i32) {
+    dbg_assert!(x >= 0 && x < 0x10000);
+    dbg_assert!(y >= 0 && y < 0x10000);
+    sub(x, y, OPSIZE_16);
+}
+pub unsafe fn cmp32(x: i32, y: i32) { sub(x, y, OPSIZE_32); }
+unsafe fn inc(dest_operand: i32, op_size: i32) -> i32 {
+    *flags = *flags & !1 | getcf() as i32;
+    let res = (dest_operand + 1) & opsize_to_mask(op_size);
+    *last_op1 = dest_operand;
+    *last_result = res;
+    *last_op_size = op_size;
+    *flags_changed = FLAGS_ALL & !1;
+    return res;
+}
+unsafe fn dec(dest_operand: i32, op_size: i32) -> i32 {
+    *flags = *flags & !1 | getcf() as i32;
+    let res = (dest_operand - 1) & opsize_to_mask(op_size);
+    *last_op1 = dest_operand;
+    *last_result = res;
+    *last_op_size = op_size;
+    *flags_changed = FLAGS_ALL & !1 | FLAG_SUB;
+    return res;
+}
+#[no_mangle]
+pub unsafe fn inc8(x: i32) -> i32 { return inc(x, OPSIZE_8); }
+pub unsafe fn inc16(x: i32) -> i32 { return inc(x, OPSIZE_16); }
+pub unsafe fn inc32(x: i32) -> i32 { return inc(x, OPSIZE_32); }
+#[no_mangle]
+pub unsafe fn dec8(x: i32) -> i32 { return dec(x, OPSIZE_8); }
+pub unsafe fn dec16(x: i32) -> i32 { return dec(x, OPSIZE_16); }
+pub unsafe fn dec32(x: i32) -> i32 { return dec(x, OPSIZE_32); }
+
+unsafe fn neg(dest_operand: i32, op_size: i32) -> i32 { sub(0, dest_operand, op_size) }
+#[no_mangle]
+pub unsafe fn not8(x: i32) -> i32 { return !x; }
+#[no_mangle]
+pub unsafe fn neg8(x: i32) -> i32 { return neg(x, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn neg16(x: i32) -> i32 { return neg(x, OPSIZE_16); }
+pub unsafe fn neg32(x: i32) -> i32 { return neg(x, OPSIZE_32); }
+
+#[no_mangle]
+pub unsafe fn mul8(source_operand: i32) {
+    let result = source_operand * read_reg8(AL);
+    write_reg16(AX, result);
+    *last_result = result & 255;
+    *last_op_size = OPSIZE_8;
+    if result < 256 {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    else {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+}
+#[no_mangle]
+pub unsafe fn imul8(source_operand: i32) {
+    let result = source_operand * (read_reg8(AL) << 24 >> 24);
+    write_reg16(AX, result);
+    *last_result = result & 255;
+    *last_op_size = OPSIZE_8;
+    if result > 127 || result < -128 {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    else {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+}
+#[no_mangle]
+pub unsafe fn mul16(source_operand: u32) {
+    let result = source_operand * read_reg16(AX) as u32;
+    let high_result = result >> 16;
+    write_reg16(AX, result as i32);
+    write_reg16(DX, high_result as i32);
+    *last_result = (result & 0xFFFF) as i32;
+    *last_op_size = OPSIZE_16;
+    if high_result == 0 {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    else {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+}
+#[no_mangle]
+pub unsafe fn imul16(source_operand: i32) {
+    let result = source_operand * (read_reg16(AX) << 16 >> 16);
+    write_reg16(AX, result);
+    write_reg16(DX, result >> 16);
+    *last_result = result & 0xFFFF;
+    *last_op_size = OPSIZE_16;
+    if result > 32767 || result < -32768 {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    else {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+}
+#[no_mangle]
+pub unsafe fn imul_reg16(mut operand1: i32, mut operand2: i32) -> i32 {
+    operand1 = operand1 << 16 >> 16;
+    operand2 = operand2 << 16 >> 16;
+    let result = operand1 * operand2;
+    *last_result = result & 0xFFFF;
+    *last_op_size = OPSIZE_16;
+    if result > 32767 || result < -32768 {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    else {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+    return result;
+}
+#[no_mangle]
+pub unsafe fn mul32(source_operand: i32) {
+    let dest_operand = read_reg32(EAX);
+    let result = (dest_operand as u32 as u64) * (source_operand as u32 as u64);
+    let result_low = result as i32;
+    let result_high = (result >> 32) as i32;
+    write_reg32(EAX, result_low);
+    write_reg32(EDX, result_high);
+    *last_result = result_low;
+    *last_op_size = OPSIZE_32;
+    if result_high == 0 {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    else {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+}
+pub unsafe fn imul32(source_operand: i32) {
+    let dest_operand = read_reg32(EAX);
+    let result = dest_operand as i64 * source_operand as i64;
+    let result_low = result as i32;
+    let result_high = (result >> 32) as i32;
+    write_reg32(EAX, result_low);
+    write_reg32(EDX, result_high);
+    *last_result = result_low;
+    *last_op_size = OPSIZE_32;
+    if result_high == result_low >> 31 {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    else {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+}
+pub unsafe fn imul_reg32(operand1: i32, operand2: i32) -> i32 {
+    let result = operand1 as i64 * operand2 as i64;
+    let result_low = result as i32;
+    let result_high = (result >> 32) as i32;
+    *last_result = result_low;
+    *last_op_size = OPSIZE_32;
+    if result_high == result_low >> 31 {
+        *flags &= !1 & !FLAG_OVERFLOW
+    }
+    else {
+        *flags |= 1 | FLAG_OVERFLOW
+    }
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+    return result_low;
+}
+
+#[no_mangle]
+pub unsafe fn xadd8(source_operand: i32, reg: i32) -> i32 {
+    let tmp = read_reg8(reg);
+    write_reg8(reg, source_operand);
+    return add(source_operand, tmp, OPSIZE_8);
+}
+#[no_mangle]
+pub unsafe fn xadd16(source_operand: i32, reg: i32) -> i32 {
+    let tmp = read_reg16(reg);
+    write_reg16(reg, source_operand);
+    return add(source_operand, tmp, OPSIZE_16);
+}
+pub unsafe fn xadd32(source_operand: i32, reg: i32) -> i32 {
+    let tmp = read_reg32(reg);
+    write_reg32(reg, source_operand);
+    return add(source_operand, tmp, OPSIZE_32);
+}
+
+#[no_mangle]
+pub unsafe fn cmpxchg8(data: i32, r: i32) -> i32 {
+    cmp8(read_reg8(AL), data);
+    if getzf() {
+        read_reg8(r)
+    }
+    else {
+        write_reg8(AL, data);
+        data
+    }
+}
+#[no_mangle]
+pub unsafe fn cmpxchg16(data: i32, r: i32) -> i32 {
+    cmp16(read_reg16(AX), data);
+    if getzf() {
+        read_reg16(r)
+    }
+    else {
+        write_reg16(AX, data);
+        data
+    }
+}
+pub unsafe fn cmpxchg32(data: i32, r: i32) -> i32 {
+    cmp32(read_reg32(EAX), data);
+    if getzf() {
+        read_reg32(r)
+    }
+    else {
+        write_reg32(EAX, data);
+        data
+    }
+}
+
+#[no_mangle]
+pub unsafe fn bcd_daa() {
+    let old_al = read_reg8(AL);
+    let old_cf = getcf();
+    let old_af = getaf();
+    *flags &= !1 & !FLAG_ADJUST;
+    if old_al & 15 > 9 || old_af {
+        write_reg8(AL, read_reg8(AL) + 6);
+        *flags |= FLAG_ADJUST
+    }
+    if old_al > 153 || old_cf {
+        write_reg8(AL, read_reg8(AL) + 96);
+        *flags |= 1
+    }
+    *last_result = read_reg8(AL);
+    *last_op_size = OPSIZE_8;
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
+}
+#[no_mangle]
+pub unsafe fn bcd_das() {
+    let old_al = read_reg8(AL);
+    let old_cf = getcf();
+    *flags &= !1;
+    if old_al & 15 > 9 || getaf() {
+        write_reg8(AL, read_reg8(AL) - 6);
+        *flags |= FLAG_ADJUST;
+        *flags = *flags & !1 | old_cf as i32 | (old_al < 6) as i32
+    }
+    else {
+        *flags &= !FLAG_ADJUST
+    }
+    if old_al > 153 || old_cf {
+        write_reg8(AL, read_reg8(AL) - 96);
+        *flags |= 1
+    }
+    *last_result = read_reg8(AL);
+    *last_op_size = OPSIZE_8;
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
+}
+#[no_mangle]
+pub unsafe fn bcd_aad(imm8: i32) {
+    let result = read_reg8(AL) + read_reg8(AH) * imm8;
+    *last_result = result & 255;
+    write_reg16(AX, *last_result);
+    *last_op_size = OPSIZE_8;
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
+    *flags &= !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
+    if result > 0xFFFF {
+        *flags |= 1
+    };
+}
+#[no_mangle]
+pub unsafe fn bcd_aam(imm8: i32) {
+    // ascii adjust after multiplication
+    if imm8 == 0 {
+        trigger_de();
+    }
+    else {
+        let temp = read_reg8(AL);
+        write_reg8(AH, temp as i32 / imm8);
+        write_reg8(AL, temp as i32 % imm8);
+        *last_result = read_reg8(AL);
+        *last_op_size = OPSIZE_8;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_ADJUST & !FLAG_OVERFLOW;
+        *flags &= !1 & !FLAG_ADJUST & !FLAG_OVERFLOW
+    };
+}
+#[no_mangle]
+pub unsafe fn bcd_aaa() {
+    if read_reg8(AL) & 15 > 9 || getaf() {
+        write_reg16(AX, read_reg16(AX) + 6);
+        write_reg8(AH, read_reg8(AH) + 1);
+        *flags |= FLAG_ADJUST | 1
+    }
+    else {
+        *flags &= !FLAG_ADJUST & !1
+    }
+    write_reg8(AL, read_reg8(AL) & 15);
+    *flags_changed &= !FLAG_ADJUST & !1;
+}
+#[no_mangle]
+pub unsafe fn bcd_aas() {
+    if read_reg8(AL) & 15 > 9 || getaf() {
+        write_reg16(AX, read_reg16(AX) - 6);
+        write_reg8(AH, read_reg8(AH) - 1);
+        *flags |= FLAG_ADJUST | 1
+    }
+    else {
+        *flags &= !FLAG_ADJUST & !1
+    }
+    write_reg8(AL, read_reg8(AL) & 15);
+    *flags_changed &= !FLAG_ADJUST & !1;
+}
+unsafe fn and(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let result = dest_operand & source_operand;
+    *last_result = result;
+    *last_op_size = op_size;
+    *flags &= !1 & !FLAG_OVERFLOW & !FLAG_ADJUST;
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW & !FLAG_ADJUST;
+    return result;
+}
+unsafe fn or(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let result = dest_operand | source_operand;
+    *last_result = result;
+    *last_op_size = op_size;
+    *flags &= !1 & !FLAG_OVERFLOW & !FLAG_ADJUST;
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW & !FLAG_ADJUST;
+    return result;
+}
+unsafe fn xor(dest_operand: i32, source_operand: i32, op_size: i32) -> i32 {
+    let result = dest_operand ^ source_operand;
+    *last_result = result;
+    *last_op_size = op_size;
+    *flags &= !1 & !FLAG_OVERFLOW & !FLAG_ADJUST;
+    *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW & !FLAG_ADJUST;
+    return result;
+}
+pub unsafe fn and8(x: i32, y: i32) -> i32 { return and(x, y, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn and16(x: i32, y: i32) -> i32 { return and(x, y, OPSIZE_16); }
+pub unsafe fn and32(x: i32, y: i32) -> i32 { return and(x, y, OPSIZE_32); }
+pub unsafe fn test8(x: i32, y: i32) { and(x, y, OPSIZE_8); }
+pub unsafe fn test16(x: i32, y: i32) { and(x, y, OPSIZE_16); }
+pub unsafe fn test32(x: i32, y: i32) { and(x, y, OPSIZE_32); }
+pub unsafe fn or8(x: i32, y: i32) -> i32 { return or(x, y, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn or16(x: i32, y: i32) -> i32 { return or(x, y, OPSIZE_16); }
+pub unsafe fn or32(x: i32, y: i32) -> i32 { return or(x, y, OPSIZE_32); }
+pub unsafe fn xor8(x: i32, y: i32) -> i32 { return xor(x, y, OPSIZE_8); }
+#[no_mangle]
+pub unsafe fn xor16(x: i32, y: i32) -> i32 { return xor(x, y, OPSIZE_16); }
+pub unsafe fn xor32(x: i32, y: i32) -> i32 { return xor(x, y, OPSIZE_32); }
+
+#[no_mangle]
+pub unsafe fn rol8(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        count &= 7;
+        let result = dest_operand << count | dest_operand >> 8 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result & 1
+            | (result << 11 ^ result << 4) & FLAG_OVERFLOW;
+        return result & 0xFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn rol16(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        count &= 15;
+        let result = dest_operand << count | dest_operand >> 16 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result & 1
+            | (result << 11 ^ result >> 4) & FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn rol32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let result = ((dest_operand << count) as u32 | dest_operand as u32 >> 32 - count) as i32;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result & 1
+            | (result << 11 ^ result >> 20) & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn rcl8(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    count %= 9;
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let result =
+            dest_operand << count | (getcf() as i32) << count - 1 | dest_operand >> 9 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 8 & 1
+            | (result << 3 ^ result << 4) & FLAG_OVERFLOW;
+        return result & 0xFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn rcl16(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    count %= 17;
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let result =
+            dest_operand << count | (getcf() as i32) << count - 1 | dest_operand >> 17 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 16 & 1
+            | (result >> 5 ^ result >> 4) & FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn rcl32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let mut result = dest_operand << count | (getcf() as i32) << count - 1;
+        if count > 1 {
+            result = (result as u32 | dest_operand as u32 >> 33 - count) as i32
+        }
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        let b = (dest_operand as u32 >> 32 - count & 1) as i32;
+        *flags = (*flags & !1 & !FLAG_OVERFLOW | b) | (b << 11 ^ result >> 20) & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn ror8(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        count &= 7;
+        let result = dest_operand >> count | dest_operand << 8 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 7 & 1
+            | (result << 4 ^ result << 5) & FLAG_OVERFLOW;
+        return result & 0xFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn ror16(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        count &= 15;
+        let result = dest_operand >> count | dest_operand << 16 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 15 & 1
+            | (result >> 4 ^ result >> 3) & FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn ror32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let result = (dest_operand as u32 >> count | (dest_operand << 32 - count) as u32) as i32;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 31 & 1
+            | (result >> 20 ^ result >> 19) & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn rcr8(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    count %= 9;
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let result =
+            dest_operand >> count | (getcf() as i32) << 8 - count | dest_operand << 9 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 8 & 1
+            | (result << 4 ^ result << 5) & FLAG_OVERFLOW;
+        return result & 0xFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn rcr16(dest_operand: i32, mut count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    count %= 17;
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let result =
+            dest_operand >> count | (getcf() as i32) << 16 - count | dest_operand << 17 - count;
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 16 & 1
+            | (result >> 4 ^ result >> 3) & FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn rcr32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if 0 == count {
+        return dest_operand;
+    }
+    else {
+        let mut result =
+            (dest_operand as u32 >> count | ((getcf() as i32) << 32 - count) as u32) as i32;
+        if count > 1 {
+            result |= dest_operand << 33 - count
+        }
+        *flags_changed &= !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | dest_operand >> count - 1 & 1
+            | (result >> 20 ^ result >> 19) & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn div8(source_operand: u32) {
+    if source_operand == 0 {
+        trigger_de();
+        return;
+    }
+    let target_operand = read_reg16(AX) as u32;
+    let result = target_operand / source_operand;
+    if result >= 0x100 {
+        trigger_de();
+        return;
+    }
+    write_reg8(AL, result as i32);
+    write_reg8(AH, (target_operand % source_operand) as i32);
+}
+
+#[no_mangle]
+pub unsafe fn idiv8(source_operand: i32) {
+    if source_operand == 0 {
+        trigger_de();
+        return;
+    }
+    let target_operand = read_reg16(AX) << 16 >> 16;
+    let result = target_operand / source_operand;
+    if result >= 0x80 || result < -0x80 {
+        trigger_de();
+        return;
+    }
+    write_reg8(AL, result);
+    write_reg8(AH, target_operand % source_operand);
+}
+
+#[no_mangle]
+pub unsafe fn div16_without_fault(source_operand: u32) -> bool {
+    let target_operand = (read_reg16(AX) | read_reg16(DX) << 16) as u32;
+    let result = match target_operand.checked_div(source_operand) {
+        None => return false,
+        Some(r) => r,
+    };
+    if result >= 0x10000 {
+        return false;
+    }
+    write_reg16(AX, result as i32);
+    write_reg16(DX, (target_operand % source_operand) as i32);
+    return true;
+}
+pub unsafe fn div16(source_operand: u32) {
+    if !div16_without_fault(source_operand) {
+        trigger_de()
+    }
+}
+#[no_mangle]
+pub unsafe fn idiv16_without_fault(source_operand: i32) -> bool {
+    let target_operand = read_reg16(AX) | read_reg16(DX) << 16;
+    let result = match target_operand.checked_div(source_operand) {
+        None => return false,
+        Some(r) => r,
+    };
+    if result >= 0x8000 || result < -0x8000 {
+        return false;
+    }
+    write_reg16(AX, result);
+    write_reg16(DX, (target_operand % source_operand) as i32);
+    return true;
+}
+pub unsafe fn idiv16(source_operand: i32) {
+    if !idiv16_without_fault(source_operand) {
+        trigger_de()
+    }
+}
+
+#[no_mangle]
+pub unsafe fn div32_without_fault(source_operand: u32) -> bool {
+    let source_operand = source_operand as u64;
+    let target_low = read_reg32(EAX) as u32;
+    let target_high = read_reg32(EDX) as u32;
+    let target_operand = (target_high as u64) << 32 | target_low as u64;
+    let result = match target_operand.checked_div(source_operand) {
+        None => return false,
+        Some(r) => r,
+    };
+    if result > 0xFFFFFFFF {
+        return false;
+    }
+    let modulo = target_operand % source_operand;
+    write_reg32(EAX, result as i32);
+    write_reg32(EDX, modulo as i32);
+    return true;
+}
+pub unsafe fn div32(source_operand: u32) {
+    if !div32_without_fault(source_operand) {
+        trigger_de()
+    }
+}
+#[no_mangle]
+pub unsafe fn idiv32_without_fault(source_operand: i32) -> bool {
+    let source_operand = source_operand as i64;
+    let target_low = read_reg32(EAX) as u32;
+    let target_high = read_reg32(EDX) as u32;
+    let target_operand = (target_high as i64) << 32 | target_low as i64;
+    let result = match target_operand.checked_div(source_operand) {
+        None => return false,
+        Some(r) => r,
+    };
+    if result < -0x80000000 || result > 0x7FFFFFFF {
+        return false;
+    }
+    let modulo = target_operand % source_operand;
+    write_reg32(EAX, result as i32);
+    write_reg32(EDX, modulo as i32);
+    return true;
+}
+pub unsafe fn idiv32(source_operand: i32) {
+    if !idiv32_without_fault(source_operand) {
+        trigger_de()
+    }
+}
+
+#[no_mangle]
+pub unsafe fn shl8(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = dest_operand << count;
+        *last_result = result;
+        *last_op_size = OPSIZE_8;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 8 & 1
+            | (result << 3 ^ result << 4) & FLAG_OVERFLOW;
+        return result & 0xFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn shl16(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = dest_operand << count;
+        *last_result = result;
+        *last_op_size = OPSIZE_16;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | result >> 16 & 1
+            | (result >> 5 ^ result >> 4) & FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+pub unsafe fn shl32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = dest_operand << count;
+        *last_result = result;
+        *last_op_size = OPSIZE_32;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        let b = dest_operand >> 32 - count & 1;
+        *flags = *flags & !1 & !FLAG_OVERFLOW | b | (b ^ result >> 31) << 11 & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn shr8(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = dest_operand >> count;
+        *last_result = result;
+        *last_op_size = OPSIZE_8;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | dest_operand >> count - 1 & 1
+            | (dest_operand >> 7 & 1) << 11 & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn shr16(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = dest_operand >> count;
+        *last_result = result;
+        *last_op_size = OPSIZE_16;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !1 & !FLAG_OVERFLOW
+            | dest_operand >> count - 1 & 1
+            | dest_operand >> 4 & FLAG_OVERFLOW;
+        return result;
+    };
+}
+pub unsafe fn shr32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = (dest_operand as u32 >> count) as i32;
+        *last_result = result;
+        *last_op_size = OPSIZE_32;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = (*flags & !1 & !FLAG_OVERFLOW)
+            | (dest_operand as u32 >> count - 1 & 1) as i32
+            | (dest_operand >> 20 & FLAG_OVERFLOW);
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn sar8(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result;
+        if count < 8 {
+            result = dest_operand << 24 >> count + 24;
+            // of is zero
+            *flags = *flags & !1 & !FLAG_OVERFLOW | dest_operand >> count - 1 & 1
+        }
+        else {
+            result = dest_operand << 24 >> 31;
+            *flags = *flags & !1 & !FLAG_OVERFLOW | result & 1
+        }
+        *last_result = result;
+        *last_op_size = OPSIZE_8;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        return result & 0xFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn sar16(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result;
+        if count < 16 {
+            result = dest_operand << 16 >> count + 16;
+            *flags = *flags & !1 & !FLAG_OVERFLOW | dest_operand >> count - 1 & 1
+        }
+        else {
+            result = dest_operand << 16 >> 31;
+            *flags = *flags & !1 & !FLAG_OVERFLOW | result & 1
+        }
+        *last_result = result;
+        *last_op_size = OPSIZE_16;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+pub unsafe fn sar32(dest_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = dest_operand >> count;
+        *last_result = result;
+        *last_op_size = OPSIZE_32;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = (*flags & !1 & !FLAG_OVERFLOW) | (dest_operand as u32 >> count - 1 & 1) as i32;
+        return result;
+    };
+}
+
+#[no_mangle]
+pub unsafe fn shrd16(dest_operand: i32, source_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result;
+        if count <= 16 {
+            result = dest_operand >> count | source_operand << 16 - count;
+            *flags = *flags & !1 | dest_operand >> count - 1 & 1
+        }
+        else {
+            result = dest_operand << 32 - count | source_operand >> count - 16;
+            *flags = *flags & !1 | source_operand >> count - 17 & 1
+        }
+        *last_result = result;
+        *last_op_size = OPSIZE_16;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !FLAG_OVERFLOW | (result ^ dest_operand) >> 4 & FLAG_OVERFLOW;
+        return result & 0xFFFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn shrd32(dest_operand: i32, source_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = (dest_operand as u32 >> count | (source_operand << 32 - count) as u32) as i32;
+        *last_result = result;
+        *last_op_size = OPSIZE_32;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = ((*flags & !1 & !FLAG_OVERFLOW) | (dest_operand as u32 >> count - 1 & 1) as i32)
+            | (result ^ dest_operand) >> 20 & FLAG_OVERFLOW;
+        return result;
+    };
+}
+#[no_mangle]
+pub unsafe fn shld16(dest_operand: i32, source_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result;
+        if count <= 16 {
+            result = ((dest_operand << count) as u32 | source_operand as u32 >> 16 - count) as i32;
+            *flags = (*flags & !1) | (dest_operand as u32 >> 16 - count & 1) as i32;
+        }
+        else {
+            result = dest_operand >> 32 - count | source_operand << count - 16;
+            *flags = (*flags & !1) | (source_operand as u32 >> 32 - count & 1) as i32;
+        }
+        *last_result = result;
+        *last_op_size = OPSIZE_16;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = *flags & !FLAG_OVERFLOW | (*flags & 1 ^ result >> 15 & 1) << 11;
+        return result & 0xFFFF;
+    };
+}
+#[no_mangle]
+pub unsafe fn shld32(dest_operand: i32, source_operand: i32, count: i32) -> i32 {
+    dbg_assert!(count >= 0 && count < 32);
+    if count == 0 {
+        return dest_operand;
+    }
+    else {
+        let result = ((dest_operand << count) as u32 | source_operand as u32 >> 32 - count) as i32;
+        *last_result = result;
+        *last_op_size = OPSIZE_32;
+        *flags_changed = FLAGS_ALL & !1 & !FLAG_OVERFLOW;
+        *flags = (*flags & !1) | (dest_operand as u32 >> 32 - count & 1) as i32;
+        if count == 1 {
+            *flags = *flags & !FLAG_OVERFLOW | (*flags & 1 ^ result >> 31 & 1) << 11
+        }
+        else {
+            *flags &= !FLAG_OVERFLOW
+        }
+        return result;
+    };
+}
+
+pub unsafe fn bt_reg(bit_base: i32, bit_offset: i32) {
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+}
+pub unsafe fn btc_reg(bit_base: i32, bit_offset: i32) -> i32 {
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+    return bit_base ^ 1 << bit_offset;
+}
+pub unsafe fn bts_reg(bit_base: i32, bit_offset: i32) -> i32 {
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+    return bit_base | 1 << bit_offset;
+}
+pub unsafe fn btr_reg(bit_base: i32, bit_offset: i32) -> i32 {
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+    return bit_base & !(1 << bit_offset);
+}
+
+pub unsafe fn bt_mem(virt_addr: i32, mut bit_offset: i32) {
+    let bit_base = return_on_pagefault!(safe_read8(virt_addr + (bit_offset >> 3)));
+    bit_offset &= 7;
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+}
+pub unsafe fn btc_mem(virt_addr: i32, mut bit_offset: i32) {
+    let phys_addr = return_on_pagefault!(translate_address_write(virt_addr + (bit_offset >> 3)));
+    let bit_base = memory::read8(phys_addr);
+    bit_offset &= 7;
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+    memory::write8(phys_addr, bit_base ^ 1 << bit_offset);
+}
+pub unsafe fn btr_mem(virt_addr: i32, mut bit_offset: i32) {
+    let phys_addr = return_on_pagefault!(translate_address_write(virt_addr + (bit_offset >> 3)));
+    let bit_base = memory::read8(phys_addr);
+    bit_offset &= 7;
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+    memory::write8(phys_addr, bit_base & !(1 << bit_offset));
+}
+pub unsafe fn bts_mem(virt_addr: i32, mut bit_offset: i32) {
+    let phys_addr = return_on_pagefault!(translate_address_write(virt_addr + (bit_offset >> 3)));
+    let bit_base = memory::read8(phys_addr);
+    bit_offset &= 7;
+    *flags = *flags & !1 | bit_base >> bit_offset & 1;
+    *flags_changed &= !1;
+    memory::write8(phys_addr, bit_base | 1 << bit_offset);
+}
+
+#[no_mangle]
+pub unsafe fn bsf16(old: i32, bit_base: i32) -> i32 {
+    *flags_changed = FLAGS_ALL & !FLAG_ZERO & !FLAG_CARRY;
+    *flags &= !FLAG_CARRY;
+    *last_op_size = OPSIZE_16;
+    if bit_base == 0 {
+        *flags |= FLAG_ZERO;
+        *last_result = bit_base;
+        // not defined in the docs, but value doesn't change on my intel machine
+        return old;
+    }
+    else {
+        *flags &= !FLAG_ZERO;
+        *last_result = int_log2(-bit_base & bit_base);
+        return *last_result;
+    };
+}
+#[no_mangle]
+pub unsafe fn bsf32(old: i32, bit_base: i32) -> i32 {
+    *flags_changed = FLAGS_ALL & !FLAG_ZERO & !FLAG_CARRY;
+    *flags &= !FLAG_CARRY;
+    *last_op_size = OPSIZE_32;
+    if bit_base == 0 {
+        *flags |= FLAG_ZERO;
+        *last_result = bit_base;
+        return old;
+    }
+    else {
+        *flags &= !FLAG_ZERO;
+        *last_result = int_log2(-bit_base & bit_base);
+        return *last_result;
+    };
+}
+#[no_mangle]
+pub unsafe fn bsr16(old: i32, bit_base: i32) -> i32 {
+    *flags_changed = FLAGS_ALL & !FLAG_ZERO & !FLAG_CARRY;
+    *flags &= !FLAG_CARRY;
+    *last_op_size = OPSIZE_16;
+    if bit_base == 0 {
+        *flags |= FLAG_ZERO;
+        *last_result = bit_base;
+        return old;
+    }
+    else {
+        *flags &= !FLAG_ZERO;
+        *last_result = int_log2(bit_base);
+        return *last_result;
+    };
+}
+#[no_mangle]
+pub unsafe fn bsr32(old: i32, bit_base: i32) -> i32 {
+    *flags_changed = FLAGS_ALL & !FLAG_ZERO & !FLAG_CARRY;
+    *flags &= !FLAG_CARRY;
+    *last_op_size = OPSIZE_32;
+    if bit_base == 0 {
+        *flags |= FLAG_ZERO;
+        *last_result = bit_base;
+        return old;
+    }
+    else {
+        *flags &= !FLAG_ZERO;
+        *last_result = int_log2(bit_base);
+        return *last_result;
+    };
+}
+#[no_mangle]
+pub unsafe fn popcnt(v: i32) -> i32 {
+    *flags_changed = 0;
+    *flags &= !FLAGS_ALL;
+    if 0 != v {
+        return v.count_ones() as i32;
+    }
+    else {
+        *flags |= FLAG_ZERO;
+        return 0;
+    };
+}
+
+pub unsafe fn saturate_sw_to_ub(v: u16) -> u8 {
+    let mut ret = v;
+    if ret >= 32768 {
+        ret = 0
+    }
+    else if ret > 255 {
+        ret = 255
+    }
+    return ret as u8;
+}
+pub unsafe fn saturate_sw_to_sb(v: i32) -> u8 {
+    dbg_assert!(v as u32 & 0xFFFF_0000 == 0);
+    let mut ret = v;
+    if ret > 65408 {
+        ret = ret & 255
+    }
+    else if ret > 32767 {
+        ret = 128
+    }
+    else if ret > 127 {
+        ret = 127
+    }
+    dbg_assert!(ret as u32 & 0xFFFF_FF00 == 0);
+    return ret as u8;
+}
+pub unsafe fn saturate_sd_to_sw(v: u32) -> u16 {
+    let mut ret = v;
+    if ret > 4294934528 {
+        ret = ret & 0xFFFF
+    }
+    else if ret > 0x7FFFFFFF {
+        ret = 32768
+    }
+    else if ret > 32767 {
+        ret = 32767
+    }
+    dbg_assert!(ret & 0xFFFF_0000 == 0);
+    return ret as u16;
+}
+pub unsafe fn saturate_sd_to_sb(v: u32) -> i8 {
+    let mut ret = v;
+    if ret > 0xFFFFFF80 {
+        ret = ret & 255
+    }
+    else if ret > 0x7FFFFFFF {
+        ret = 128
+    }
+    else if ret > 127 {
+        ret = 127
+    }
+    dbg_assert!(ret & 0xFFFF_FF00 == 0);
+    return ret as i8;
+}
+pub unsafe fn saturate_sd_to_ub(v: i32) -> i32 {
+    let mut ret = v;
+    if ret < 0 {
+        ret = 0
+    }
+    dbg_assert!(ret as u32 & 0xFFFF_FF00 == 0);
+    return ret;
+}
+pub unsafe fn saturate_ud_to_ub(v: u32) -> u8 {
+    let mut ret = v;
+    if ret > 255 {
+        ret = 255
+    }
+    dbg_assert!(ret & 0xFFFF_FF00 == 0);
+    return ret as u8;
+}
+pub unsafe fn saturate_uw(v: u32) -> u16 {
+    let mut ret = v;
+    if ret > 0x7FFFFFFF {
+        ret = 0
+    }
+    else if ret > 0xFFFF {
+        ret = 0xFFFF
+    }
+    dbg_assert!(ret & 0xFFFF_0000 == 0);
+    return ret as u16;
+}