uint16_t sign_extend(uint16_t x, int bit_count) {
    if ((x >> (bit_count - 1)) & 1) {
        /* 取出最高位的符号位,&1: 检查符号位是否为1。如果结果为1，表示 x 是一个负数,则进行掩码拓展 */
        x |= (0xFFFF << bit_count);/* 0xFFFF << bit_count生成一个掩码;|运算将掩码应用到原始值 x 上 */
    }
    return x;
}

/* 传入需要检查的寄存器的索引 */
void update_flags(uint16_t r) {
    if (reg[r] == 0) {
        reg[R_COND] = FL_ZRO;
    }
    else if (reg[r] >> 15) { /* 检查这个被写入值的寄存器的最高位（符号位） */
        reg[R_COND] = FL_NEG;/* 如果最高位为1，则设置条件标记为负标志（FL_NEG），表示结果为负数 */
    } else {
        reg[R_COND] = FL_POS;
    }
}

{   /*0x7 是一个二进制数 00000111用于掩码操作，利用同状态才为真的性质可以去除掉无关位数据的干扰*/
    uint16_t r0 = (instr >> 9) & 0x7; /* destination register (DR) */
    uint16_t r1 = (instr >> 6) & 0x7; /* first operand (SR1) */
    uint16_t imm_flag = (instr >> 5) & 0x1; /* whether we are in immediate mode */

    if (imm_flag) {
        uint16_t imm5 = sign_extend(instr & 0x1F, 5);
        reg[r0] = reg[r1] + imm5;
    } else {
        uint16_t r2 = instr & 0x7;
        reg[r0] = reg[r1] + reg[r2];
    }

    update_flags(r0);
}

{
    uint16_t pc_offset = sign_extend((instr) & 0x1ff, 9);
    uint16_t cond_flag = (instr >> 9) & 0x7;/*获取条件位(因为这个指令的操作码是0000，所以我们直接&取数据就行了)*/
    if (cond_flag & reg[R_COND]) {/*检查标志位，判断前一次指令的计算结果，此时就用上了update_flags(r0)*/
        reg[R_PC] += pc_offset;/* 写入pc寄存器，改变执行流 */
    }
}

void read_image_file(FILE* file) {
    uint16_t origin; /* the origin tells us where in memory to place the image */
    fread(&origin, sizeof(origin), 1, file);
    origin = swap16(origin);/* 转换为大端序 */

   
    uint16_t max_read = UINT16_MAX - origin;/* 除去origin后剩余的文件数据 */
    uint16_t* p = memory + origin;/* 文件数据应该被放置在物理机内存中的起始位置 */
    size_t read = fread(p, sizeof(uint16_t), max_read, file);/* 读取 max_read 个 uint16_t 类型的数据。将文件数据按lc-3的内存结构排列在物理机内存中 */

    /* swap to little endian */
    while (read-- > 0) {
        *p = swap16(*p);
        ++p;
    }
}

void mem_write(uint16_t address, uint16_t val) {
    memory[address] = val;
}

uint16_t mem_read(uint16_t address)
{
    if (address == MR_KBSR) {
        if (check_key()) {
            memory[MR_KBSR] = (1 << 15);/*当访问键盘输入寄存器时，写入操作会对内存状态寄存器执行写入操作。
            表面此时把键盘的输入信息存到了这个寄存器中*/
            memory[MR_KBDR] = getchar();
        } else {
            memory[MR_KBSR] = 0;/* 没有键按下，清空 KBSR */
        }
    }
    return memory[address];
}

unsigned __int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  memset(s, 0, 0x300uLL);
  write(1, "opcode: ", 8uLL);
  read(0, s, 0x300uLL);
  sub_1230(&unk_40C0, s, 0x300LL);
  sub_19F1(&unk_40C0);
}

_QWORD *__fastcall sub_1230(_QWORD *a1, __int64 a2, __int64 a3)
{
  _QWORD *result; // rax
  int i; // [rsp+24h] [rbp-4h]

  a1[33] = a2;
  a1[34] = a3;
  result = a1;
  a1[32] = 0LL;
  for ( i = 0; i <= 31; ++i )
  {
    result = a1;
    a1[i] = 0LL;
  }
  return result;
}

vm_mem *__fastcall sub_1230(vm_mem *vm_mem, char *a2, __int64 a3)
{
  vm_mem *result; // rax
  int i; // [rsp+24h] [rbp-4h]

  vm_mem->opcode = a2;
  vm_mem->max_len = a3;
  result = vm_mem;
  vm_mem->rip = 0LL;
  for ( i = 0; i <= 31; ++i )
  {
    result = vm_mem;
    vm_mem->reg[i] = 0LL;
  }
  return result;
}

unsigned __int64 __fastcall disassemble(vm_mem *a1)
{
  unsigned int high_bit; // [rsp+1Ch] [rbp-114h]
  char s[264]; // [rsp+20h] [rbp-110h] BYREF
  unsigned __int64 v4; // [rsp+128h] [rbp-8h]


  memset(s, 0, 0x100uLL);                       /* 这里用结构体寻址+索引来定位 */
  while ( a1->rip < (unsigned __int64)a1->max_len )
  {
    high_bit = *(_DWORD *)&a1->opcode[a1->rip & 0xFFFFFFFFFFFFFFFCLL] >> 28;/*第一字节为标志位,
    &0xFFFFFFFFFFFFFFF保证四字节对齐，可以推断出为32位*/
    if ( high_bit > 0xA || !high_bit )
    {
      puts("Unsupported instruction");
      return v4 - __readfsqword(0x28u);
    }
    ((void (__fastcall *)(vm_mem *, char *))to_opcode[high_bit])(a1, s);/* 点进这个to_opcode数组，可以看到对应指令的处理函数,一个一个逆就行了 */
  }
  
}

void __fastcall add(vm_mem *a1)
{
  unsigned int used_opcode; // [rsp+10h] [rbp-10h]

  used_opcode = *(_DWORD *)&a1->opcode[a1->rip & 0xFFFFFFFFFFFFFFFCLL];/* 指令码为32位 */
  a1->rip += 4LL;/* 自增4指向下一个指令 */
  a1->reg[used_opcode & 0x1F] = a1->reg[HIWORD(used_opcode) & 0x1F] + a1->reg[(used_opcode >> 5) & 0x1F];
} 

char *__fastcall store(vm_mem *a1, char *sta_base)
{
  char *result; // rax
  unsigned int used_opcode; // [rsp+20h] [rbp-20h]
  char *v4; // [rsp+30h] [rbp-10h]

  used_opcode = *(_DWORD *)(a1->opcode + (a1->rip & 0xFFFFFFFFFFFFFFFCLL));
  a1->rip += 4LL;
  result = (char *)(unsigned __int8)ffh;
  if ( (unsigned __int8)(a1->reg[(used_opcode >> 5) & 0x1F] + BYTE2(used_opcode)) < (unsigned __int8)ffh )
  /*取出右边移位5之后取出来的值对应的寄存器的值(觉得说得绕的话多看看代码)，加上右移十六位之后的opcdoe值相加*/
  {  
    v4 = &sta_base[(unsigned __int16)(a1->reg[(used_opcode >> 5) & 0x1F] + (HIWORD(used_opcode) & 0xFFF))];/*  寄存器值+偏移获取栈的地址 */
    *(_QWORD *)v4 = a1->reg[used_opcode & 0x1F];/* 把目标寄存器的值传给栈 */
    return v4;
  }
  return result;
}