LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/display.c
// Function: display_end
void display_end(void) {
  int i;
  if(log_file != NULL) {
    fclose(log_file);
    log_file = NULL;
  }
  for(i = 0; i < N_TRACE; i++) {
    if(trace_lines[i] != NULL)
      free(trace_lines[i]);
  }
  endwin();
}

// Assembly:
pushq %rax
cmpq $0x0, 0xbb47(%rip)      # 0x12b00
je 0x6fd2
movq 0xbb3e(%rip), %rdi      # 0x12b00
callq 0x2080
movq $0x0, 0xbb2e(%rip) # 0x12b00
movl $0x0, 0x4(%rsp)
cmpl $0x11, 0x4(%rsp)
jge 0x7018
movslq 0x4(%rsp), %rcx
leaq 0xbb23(%rip), %rax      # 0x12b10
cmpq $0x0, (%rax,%rcx,8)
je 0x7009
movslq 0x4(%rsp), %rcx
leaq 0xbb10(%rip), %rax      # 0x12b10
movq (%rax,%rcx,8), %rdi
callq 0x2040
jmp 0x700b
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6fda
callq 0x21f0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/prci.c
// Function: PRCI_init
int PRCI_init(struct region *r) {
  uint32_t *data;

  if(r->data != NULL) {
    display_log("PRCI already initialized");
    return 0;
  }
 
  data = malloc(r->size);
  if(data == NULL){
    return 0;
  }
  r->data = (void *)data;
  memset(r->data, 0, r->size);
  display_log("Set up PRCI region");
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x704b
leaq 0x458f(%rip), %rdi      # 0xb5cb
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x70aa
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x2180
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x706f
movl $0x0, 0x14(%rsp)
jmp 0x70aa
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x20e0
leaq 0x4547(%rip), %rdi      # 0xb5e4
callq 0x6b20
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/prci.c
// Function: PRCI_set
int PRCI_set(struct region *r, uint32_t address, uint8_t mask, uint32_t value) {
   char buffer[100];
   if(address+4 > r->size) {
     fprintf(stderr,"Memory region boundary crossed at 0x%08x\n", r->base+address);
     return 0;
   }

   if((address & 3) != 0) {
     fprintf(stderr,"Unaligned memory write 0x%08x\n", r->base+address);
   }
   sprintf(buffer,"PRCI Wr address 0x%08x: 0x%08x", address, value);
   display_log(buffer);

   if(mask & 1) {
      ((unsigned char *)r->data)[address+0] = value; 
   }
   if(mask & 2) {
      ((unsigned char *)r->data)[address+1] = value>>8; 
   }
   if(mask & 4) {
      ((unsigned char *)r->data)[address+2] = value>>16; 
   }
   if(mask & 8) {
      ((unsigned char *)r->data)[address+3] = value>>24; 
   }
   return 1;
}

// Assembly:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movb %al, 0x73(%rsp)
movl %ecx, 0x6c(%rsp)
movl 0x74(%rsp), %eax
addl $0x4, %eax
movq 0x78(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x711f
movq 0x6f06(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x74(%rsp), %edx
leaq 0x3e29(%rip), %rsi      # 0xaf31
movb $0x0, %al
callq 0x2130
movl $0x0, 0x84(%rsp)
jmp 0x7224
movl 0x74(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x714f
movq 0x6ec6(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x74(%rsp), %edx
leaq 0x3e13(%rip), %rsi      # 0xaf5b
movb $0x0, %al
callq 0x2130
movq %rsp, %rdi
movl 0x74(%rsp), %edx
movl 0x6c(%rsp), %ecx
leaq 0x4496(%rip), %rsi      # 0xb5f7
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movzbl 0x73(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7198
movl 0x6c(%rsp), %eax
movb %al, %dl
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x74(%rsp), %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movzbl 0x73(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x71c3
movl 0x6c(%rsp), %eax
shrl $0x8, %eax
movb %al, %dl
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x74(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movzbl 0x73(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x71ee
movl 0x6c(%rsp), %eax
shrl $0x10, %eax
movb %al, %dl
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x74(%rsp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movzbl 0x73(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7219
movl 0x6c(%rsp), %eax
shrl $0x18, %eax
movb %al, %dl
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x74(%rsp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/prci.c
// Function: PRCI_get
int PRCI_get(struct region *r, uint32_t address, uint32_t *value) {
   uint32_t v = 0;
   char buffer[100];
   if((address & 3) != 0) {
     fprintf(stderr,"Unaligned memory read 0x%08x\n", r->base+address);
     return 0;
   }

   if(address+4 > r->size) {
     fprintf(stderr,"Memory region boundary crossed at 0x%08x\n", r->base+address);
     return 0;
   }

   v = ((unsigned char *)r->data)[address]; 
   v = v + (((unsigned char *)r->data)[address+1] << 8); 
   v = v + (((unsigned char *)r->data)[address+2] << 16); 
   v = v + (((unsigned char *)r->data)[address+3] << 24); 

   switch(address) {
     case 0:
       v |= 1<<31; // HF Lock flag
       break;
     case 8:
       v |= 1<<31; // PLL Lock flag
       break;    
   }
   *value = v;
     
   sprintf(buffer,"PRCI Rd address 0x%08x: 0x%08x", address, v);
   display_log(buffer);

   return 1;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq %rdx, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movl 0x84(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x72ac
movq 0x6d7f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x88(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x84(%rsp), %edx
leaq 0x3ce5(%rip), %rsi      # 0xaf7a
movb $0x0, %al
callq 0x2130
movl $0x0, 0x94(%rsp)
jmp 0x7402
movl 0x84(%rsp), %eax
addl $0x4, %eax
movq 0x88(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x72fd
movq 0x6d2e(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x88(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x84(%rsp), %edx
leaq 0x3c4b(%rip), %rsi      # 0xaf31
movb $0x0, %al
callq 0x2130
movl $0x0, 0x94(%rsp)
jmp 0x7402
movq 0x88(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x84(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x88(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl 0x84(%rsp), %edx
incl %edx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x88(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl 0x84(%rsp), %edx
addl $0x2, %edx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x88(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl 0x84(%rsp), %edx
addl $0x3, %edx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, 0x74(%rsp)
movl 0x84(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x73a8
jmp 0x739d
movl 0xc(%rsp), %eax
subl $0x8, %eax
je 0x73b7
jmp 0x73c4
movl 0x74(%rsp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, 0x74(%rsp)
jmp 0x73c4
movl 0x74(%rsp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %ecx
movq 0x78(%rsp), %rax
movl %ecx, (%rax)
leaq 0x10(%rsp), %rdi
movl 0x84(%rsp), %edx
movl 0x74(%rsp), %ecx
leaq 0x4230(%rip), %rsi      # 0xb616
movb $0x0, %al
callq 0x21e0
leaq 0x10(%rsp), %rdi
callq 0x6b20
movl $0x1, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/prci.c
// Function: PRCI_free
void PRCI_free(struct region *r) {
   char buffer[100];
   sprintf(buffer, "Releasing PRCI at 0x%08x", r->base);
   display_log(buffer);
   if(r->data != NULL) 
     free(r->data);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsp, %rdi
movq 0x70(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x4115(%rip), %rsi      # 0xb650
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movq 0x70(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x7564
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/rom.c
// Function: ROM_init
int ROM_init(struct region *r) {
  uint32_t *data;

  if(r->data != NULL) {
    display_log("ROM already initialized");
    return 0;
  }
 
  data = malloc(r->size);
  if(data == NULL){
    return 0;
  }
  r->data = (void *)data;
  memset(r->data, 0, r->size);
  attempt_to_read(r);
  display_log("Set up memory region");
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x759b
leaq 0x40dd(%rip), %rdi      # 0xb669
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x7604
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x2180
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x75bf
movl $0x0, 0x14(%rsp)
jmp 0x7604
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x20e0
movq 0x8(%rsp), %rdi
callq 0x7610
leaq 0x3925(%rip), %rdi      # 0xaf1c
callq 0x6b20
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/rom.c
// Function: ROM_set
int ROM_set(struct region *r, uint32_t address, uint8_t mask, uint32_t value) {

   if(address+4 > r->size) {
     fprintf(stderr,"Memory region boundary crossed at 0x%08x\n", r->base+address);
     return 0;
   }

   if((address & 3) != 0) {
     fprintf(stderr,"Unaligned memory write 0x%08x\n", r->base+address);
   }
   display_log("Attempt to write to ROM\n");
   return 1;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movb %al, 0x13(%rsp)
movl %ecx, 0xc(%rsp)
movl 0x14(%rsp), %eax
addl $0x4, %eax
movq 0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x79e6
movq 0x6639(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x14(%rsp), %edx
leaq 0x355c(%rip), %rsi      # 0xaf31
movb $0x0, %al
callq 0x2130
movl $0x0, 0x24(%rsp)
jmp 0x7a2a
movl 0x14(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x7a16
movq 0x65ff(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x14(%rsp), %edx
leaq 0x354c(%rip), %rsi      # 0xaf5b
movb $0x0, %al
callq 0x2130
leaq 0x3c64(%rip), %rdi      # 0xb681
callq 0x6b20
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/rom.c
// Function: ROM_free
void ROM_free(struct region *r) {
   char buffer[100];
   sprintf(buffer, "Releasing ROM at 0x%08x", r->base);
   display_log(buffer);
   if(r->data != NULL) 
     free(r->data);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsp, %rdi
movq 0x70(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x3a09(%rip), %rsi      # 0xb6b4
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movq 0x70(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x7cd4
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/spi.c
// Function: SPI_init
int SPI_init(struct region *r) {
  uint32_t *data;

  if(r->data != NULL) {
    display_log("SPI already initialized");
    return 0;
  }
 
  data = malloc(r->size);
  if(data == NULL){
    return 0;
  }
  r->data = (void *)data;
  memset(r->data, 0, r->size);
  display_log("Set up SPI region");
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x7d0b
leaq 0x39dd(%rip), %rdi      # 0xb6d9
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x7d6a
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x2180
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x7d2f
movl $0x0, 0x14(%rsp)
jmp 0x7d6a
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x20e0
leaq 0x3994(%rip), %rdi      # 0xb6f1
callq 0x6b20
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/spi.c
// Function: SPI_get
int SPI_get(struct region *r, uint32_t address, uint32_t *value) {
   uint32_t v = 0;
   char buffer[100];
   if((address & 3) != 0) {
     fprintf(stderr,"Unaligned memory read 0x%08x\n", r->base+address);
     return 0;
   }

   if(address+4 > r->size) {
     fprintf(stderr,"Memory region boundary crossed at 0x%08x\n", r->base+address);
     return 0;
   }

   v = ((unsigned char *)r->data)[address]; 
   v = v + (((unsigned char *)r->data)[address+1] << 8); 
   v = v + (((unsigned char *)r->data)[address+2] << 16); 
   v = v + (((unsigned char *)r->data)[address+3] << 24); 

   if(address == 0)
     v |= 1<<31;
   *value = v;
     
   sprintf(buffer,"SPI Rd address 0x%08x: 0x%08x", address, v);
   display_log(buffer);

   return 1;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movq %rdx, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x74(%rsp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x7f5d
movq 0x60c8(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x74(%rsp), %edx
leaq 0x3034(%rip), %rsi      # 0xaf7a
movb $0x0, %al
callq 0x2130
movl $0x0, 0x84(%rsp)
jmp 0x806b
movl 0x74(%rsp), %eax
addl $0x4, %eax
movq 0x78(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x7fa2
movq 0x6083(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0x78(%rsp), %rax
movl 0x8(%rax), %edx
addl 0x74(%rsp), %edx
leaq 0x2fa6(%rip), %rsi      # 0xaf31
movb $0x0, %al
callq 0x2130
movl $0x0, 0x84(%rsp)
jmp 0x806b
movq 0x78(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x74(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq 0x78(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl 0x74(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq 0x78(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl 0x74(%rsp), %edx
addl $0x2, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq 0x78(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl 0x74(%rsp), %edx
addl $0x3, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x74(%rsp)
jne 0x8034
movl 0x64(%rsp), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, (%rax)
movq %rsp, %rdi
movl 0x74(%rsp), %edx
movl 0x64(%rsp), %ecx
leaq 0x36d0(%rip), %rsi      # 0xb721
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/spi.c
// Function: SPI_free
void SPI_free(struct region *r) {
   char buffer[100];
   sprintf(buffer, "Releasing SPI at 0x%08x", r->base);
   display_log(buffer);
   if(r->data != NULL) 
     free(r->data);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsp, %rdi
movq 0x70(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x35be(%rip), %rsi      # 0xb759
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movq 0x70(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x81c4
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/clint.c
// Function: CLINT_init
int CLINT_init(struct region *r) {
  uint32_t *data;

  if(r->data != NULL) {
    display_log("CLINT already initialized");
    return 0;
  }
 
  data = malloc(r->size);
  if(data == NULL){
    return 0;
  }
  r->data = (void *)data;
  memset(r->data, 0, r->size);
  display_log("Set up CLINT region");
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x81fb
leaq 0x3585(%rip), %rdi      # 0xb771
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x825a
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x2180
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x821f
movl $0x0, 0x14(%rsp)
jmp 0x825a
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x20e0
leaq 0x353e(%rip), %rdi      # 0xb78b
callq 0x6b20
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/clint.c
// Function: CLINT_free
void CLINT_free(struct region *r) {
   char buffer[100];
   sprintf(buffer, "Releasing CLINT at 0x%08x", r->base);
   display_log(buffer);
   if(r->data != NULL) 
     free(r->data);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsp, %rdi
movq 0x70(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x30b8(%rip), %rsi      # 0xb823
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movq 0x70(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x8794
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/gpio.c
// Function: GPIO_init
int GPIO_init(struct region *r) {
  uint32_t *data;

  if(r->data != NULL) {
    display_log("GPIO already initialized");
    return 0;
  }
 
  data = malloc(r->size);
  if(data == NULL){
    return 0;
  }
  r->data = (void *)data;
  memset(r->data, 0, r->size);
  display_log("Set up GPIO region");
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x87cb
leaq 0x3188(%rip), %rdi      # 0xb944
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x882a
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x2180
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x87ef
movl $0x0, 0x14(%rsp)
jmp 0x882a
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x20e0
leaq 0x3140(%rip), %rdi      # 0xb95d
callq 0x6b20
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/gpio.c
// Function: GPIO_free
void GPIO_free(struct region *r) {
   char buffer[100];
   sprintf(buffer, "Releasing GPIO at 0x%08x", r->base);
   display_log(buffer);
   if(r->data != NULL) 
     free(r->data);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsp, %rdi
movq 0x70(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x2cfe(%rip), %rsi      # 0xb9c9
movb $0x0, %al
callq 0x21e0
movq %rsp, %rdi
callq 0x6b20
movq 0x70(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x8cf4
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2040
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/memory.c
// Function: memory_reset
void memory_reset(void) {

  read_data_fifo.count         = 0;
  read_data_fifo.read_ptr      = 0;
  read_data_fifo.write_ptr     = 0;

  fetch_data_fifo.count        = 0;
  fetch_data_fifo.read_ptr     = 0;
  fetch_data_fifo.write_ptr    = 0;

  write_request_fifo.count     = 0;
  write_request_fifo.read_ptr  = 0;
  write_request_fifo.write_ptr = 0;

  read_request_fifo.count      = 0;
  read_request_fifo.read_ptr   = 0;
  read_request_fifo.write_ptr  = 0;
  display_log("Memory reset");
}

// Assembly:
pushq %rax
movl $0x0, 0x9f6d(%rip)      # 0x12c78
movl $0x0, 0x9f5b(%rip)      # 0x12c70
movl $0x0, 0x9f55(%rip)      # 0x12c74
movl $0x0, 0x9f7b(%rip)      # 0x12ca4
movl $0x0, 0x9f69(%rip)      # 0x12c9c
movl $0x0, 0x9f63(%rip)      # 0x12ca0
movl $0x0, 0x9f89(%rip)      # 0x12cd0
movl $0x0, 0x9f77(%rip)      # 0x12cc8
movl $0x0, 0x9f71(%rip)      # 0x12ccc
movl $0x0, 0x9fd7(%rip)      # 0x12d3c
movl $0x0, 0x9fc5(%rip)      # 0x12d34
movl $0x0, 0x9fbf(%rip)      # 0x12d38
leaq 0x2c62(%rip), %rdi      # 0xb9e2
callq 0x6b20
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/memory.c
// Function: memory_read_request
uint32_t memory_read_request(uint32_t address) {
  if(read_request_fifo.count == FIFO_SIZE)
    return 0;
  read_request_fifo.address[read_request_fifo.write_ptr] = address;
  read_request_fifo.count++;
  read_request_fifo.write_ptr = (read_request_fifo.write_ptr == FIFO_SIZE-1) ? 0 : read_request_fifo.write_ptr+1;
  return 1;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x8, 0x9f91(%rip)      # 0x12d3c
jne 0x8db7
movl $0x0, -0x4(%rsp)
jmp 0x8e0d
movl -0x8(%rsp), %edx
movl 0x9f77(%rip), %eax      # 0x12d38
movl %eax, %ecx
leaq 0x9f6a(%rip), %rax      # 0x12d34
movl %edx, 0xc(%rax,%rcx,4)
movl 0x9f68(%rip), %eax      # 0x12d3c
addl $0x1, %eax
movl %eax, 0x9f5f(%rip)      # 0x12d3c
cmpl $0x7, 0x9f54(%rip)      # 0x12d38
jne 0x8dee
xorl %eax, %eax
movl %eax, -0xc(%rsp)
jmp 0x8dfb
movl 0x9f44(%rip), %eax      # 0x12d38
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, 0x9f33(%rip)      # 0x12d38
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/memory.c
// Function: memory_fetch_request
uint32_t memory_fetch_request(uint32_t address) {
  if(fetch_request_fifo.count == FIFO_SIZE)
    return 0;

  fetch_request_fifo.address[fetch_request_fifo.write_ptr] = address;
  fetch_request_fifo.count++;
  fetch_request_fifo.write_ptr = (fetch_request_fifo.write_ptr == FIFO_SIZE-1) ? 0 : fetch_request_fifo.write_ptr+1;

  return 1;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x8, 0x9f3d(%rip)      # 0x12d68
jne 0x8e37
movl $0x0, -0x4(%rsp)
jmp 0x8e8d
movl -0x8(%rsp), %edx
movl 0x9f23(%rip), %eax      # 0x12d64
movl %eax, %ecx
leaq 0x9f16(%rip), %rax      # 0x12d60
movl %edx, 0xc(%rax,%rcx,4)
movl 0x9f14(%rip), %eax      # 0x12d68
addl $0x1, %eax
movl %eax, 0x9f0b(%rip)      # 0x12d68
cmpl $0x7, 0x9f00(%rip)      # 0x12d64
jne 0x8e6e
xorl %eax, %eax
movl %eax, -0xc(%rsp)
jmp 0x8e7b
movl 0x9ef0(%rip), %eax      # 0x12d64
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, 0x9edf(%rip)      # 0x12d64
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/memory.c
// Function: memory_read_data
uint32_t memory_read_data(void) {
  uint32_t rtn;
  if(read_data_fifo.count == 0) {
    display_log("Attempt to read empty FIFO read_data");
    return 0;
  }

  rtn = read_data_fifo.data[read_data_fifo.read_ptr];
  read_data_fifo.count--;
  read_data_fifo.read_ptr = (read_data_fifo.read_ptr == FIFO_SIZE-1) ? 0 : read_data_fifo.read_ptr+1; 
  return rtn;
}

// Assembly:
subq $0x18, %rsp
cmpl $0x0, 0x9dad(%rip)      # 0x12c78
jne 0x8ee3
leaq 0x2b1b(%rip), %rdi      # 0xb9ef
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x8f39
movl 0x9d87(%rip), %eax      # 0x12c70
movl %eax, %ecx
leaq 0x9d7e(%rip), %rax      # 0x12c70
movl 0xc(%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movl 0x9d78(%rip), %eax      # 0x12c78
addl $-0x1, %eax
movl %eax, 0x9d6f(%rip)      # 0x12c78
cmpl $0x7, 0x9d60(%rip)      # 0x12c70
jne 0x8f1a
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x8f27
movl 0x9d50(%rip), %eax      # 0x12c70
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x9d3f(%rip)      # 0x12c70
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/memory.c
// Function: memory_fetch_data
uint32_t memory_fetch_data(void) {
  uint32_t rtn;
  if(fetch_data_fifo.count == 0) {
    display_log("Attempt to read empty FIFO fetch_data");
    return 0;
  }

  rtn = fetch_data_fifo.data[fetch_data_fifo.read_ptr];
  fetch_data_fifo.count--;
  fetch_data_fifo.read_ptr = (fetch_data_fifo.read_ptr == FIFO_SIZE-1) ? 0 : fetch_data_fifo.read_ptr+1;
  return rtn;
}

// Assembly:
subq $0x18, %rsp
cmpl $0x0, 0x9d49(%rip)      # 0x12ca4
jne 0x8f73
leaq 0x2ab0(%rip), %rdi      # 0xba14
callq 0x6b20
movl $0x0, 0x14(%rsp)
jmp 0x8fc9
movl 0x9d23(%rip), %eax      # 0x12c9c
movl %eax, %ecx
leaq 0x9d1a(%rip), %rax      # 0x12c9c
movl 0xc(%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movl 0x9d14(%rip), %eax      # 0x12ca4
addl $-0x1, %eax
movl %eax, 0x9d0b(%rip)      # 0x12ca4
cmpl $0x7, 0x9cfc(%rip)      # 0x12c9c
jne 0x8faa
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x8fb7
movl 0x9cec(%rip), %eax      # 0x12c9c
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x9cdb(%rip)      # 0x12c9c
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]emulate-risc-v/memory.c
// Function: memory_write_request
int      memory_write_request(uint32_t address, uint32_t mask, uint32_t value) {
  if(write_request_fifo.count == FIFO_SIZE) {
    return 0;
  }
  write_request_fifo.address[write_request_fifo.write_ptr] = address;
  write_request_fifo.mask[write_request_fifo.write_ptr]    = mask;
  write_request_fifo.data[write_request_fifo.write_ptr]    = value;
  write_request_fifo.count++;
  write_request_fifo.write_ptr = (write_request_fifo.write_ptr == FIFO_SIZE-1) ? 0 : write_request_fifo.write_ptr+1;
  return 1; 
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
cmpl $0x8, 0x9ccd(%rip)      # 0x12cd0
jne 0x9012
movl $0x0, -0x4(%rsp)
jmp 0x9096
movl -0x8(%rsp), %edx
movl 0x9cb0(%rip), %eax      # 0x12ccc
movl %eax, %ecx
leaq 0x9ca3(%rip), %rax      # 0x12cc8
movl %edx, 0xc(%rax,%rcx,4)
movl -0xc(%rsp), %edx
movl 0x9c99(%rip), %eax      # 0x12ccc
movl %eax, %ecx
leaq 0x9c8c(%rip), %rax      # 0x12cc8
movl %edx, 0x2c(%rax,%rcx,4)
movl -0x10(%rsp), %edx
movl 0x9c82(%rip), %eax      # 0x12ccc
movl %eax, %ecx
leaq 0x9c75(%rip), %rax      # 0x12cc8
movl %edx, 0x4c(%rax,%rcx,4)
movl 0x9c73(%rip), %eax      # 0x12cd0
addl $0x1, %eax
movl %eax, 0x9c6a(%rip)      # 0x12cd0
cmpl $0x7, 0x9c5f(%rip)      # 0x12ccc
jne 0x9077
xorl %eax, %eax
movl %eax, -0x14(%rsp)
jmp 0x9084
movl 0x9c4f(%rip), %eax      # 0x12ccc
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, 0x9c3e(%rip)      # 0x12ccc
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/rain/editor_main.cpp
// Function: toID(Player)
u32 toID(Player p) {
    switch (p) {
        case (Player::P1):
            return 0;
        case (Player::P2):
            return 1;
        case (Player::P3):
            return 2;
        case (Player::P4):
            return 3;
        default:
            break;
    }
    // Safe guard return.
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x7, %eax
ja 0x284f
movq -0x10(%rbp), %rax
leaq 0x4280e(%rip), %rcx     # 0x45030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x2858
movl $0x1, -0x4(%rbp)
jmp 0x2858
movl $0x2, -0x4(%rbp)
jmp 0x2858
movl $0x3, -0x4(%rbp)
jmp 0x2858
jmp 0x2851
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/rain/editor_main.cpp
// Function: read_with_default(char const*, char const*, char*, unsigned int)
void read_with_default(const char *prompt, const char *def, char *val, u32 length) {
    s32 input_length;
    do {
        printf("%s", prompt);
        if (def)
            printf(" [%s]", def);
        printf(": ");

        fgets(val, length, stdin);
        input_length = strlen(val);
        if (val[MAX(input_length - 1, 0)] == '\n') {
            break;
        }

        printf("You passed in a too long string, max length is %d.\n", length);
        do {
            fgets(val, length, stdin);
            input_length = strlen(val);
        } while (val[MAX(input_length - 1, 0)] != '\n');
    } while (true);

    if (input_length == 2)
        memcpy((void *) def, (void *) val, strlen(def));
    else
        val[input_length - 1] = '\0';

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x439d9(%rip), %rdi     # 0x4627b
movb $0x0, %al
callq 0x2080
cmpq $0x0, -0x10(%rbp)
je 0x28c2
movq -0x10(%rbp), %rsi
leaq 0x427f5(%rip), %rdi     # 0x450b0
movb $0x0, %al
callq 0x2080
leaq 0x4363f(%rip), %rdi     # 0x45f08
movb $0x0, %al
callq 0x2080
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq 0x66712(%rip), %rax     # 0x68ff0
movq (%rax), %rdx
callq 0x22f0
movq -0x18(%rbp), %rdi
callq 0x2250
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x2910
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2917
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2917
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x292c
jmp 0x29a5
movl -0x1c(%rbp), %esi
leaq 0x42780(%rip), %rdi     # 0x450b6
movb $0x0, %al
callq 0x2080
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq 0x666a5(%rip), %rax     # 0x68ff0
movq (%rax), %rdx
callq 0x22f0
movq -0x18(%rbp), %rdi
callq 0x2250
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x297d
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2984
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2984
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x293d
jmp 0x2999
movb $0x1, %al
testb $0x1, %al
jne 0x2897
jmp 0x29a5
cmpl $0x2, -0x20(%rbp)
jne 0x29d6
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2250
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x2090
jmp 0x29e7
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/rain/editor_main.cpp
// Function: write_sprite_to_file(EditableSprite, _IO_FILE*)
void write_sprite_to_file(EditableSprite sprite, FILE *file) {
    fprintf(file, "%s:#%llu:%d:", sprite.name,
            fog_asset_hash(sprite.sheet), sprite.points.size());

    Vec2 center = fog_V2(0, 0);
    for (u32 i = 0; i < sprite.points.size(); i++) {
        center += sprite.points[i];
    }
    center /= sprite.points.size();
    for (u32 i = 0; i < sprite.points.size(); i++) {
        Vec2 p = sprite.points[i];
        fprintf(file, "(%f %f %f %f)",
            p.x - center.x, p.y - center.y,
            p.x, p.y);
    }
    fprintf(file, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq 0x18(%rdi), %rdi
callq 0x36cf0
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x53d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq %rax, %r8
leaq 0x426a7(%rip), %rsi     # 0x450ea
xorl %eax, %eax
callq 0x2170
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x372e0
movlpd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x60(%rbp)
callq 0x53d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2aab
movq -0x58(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x53f0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
callq 0x5410
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a61
movq -0x58(%rbp), %rdi
callq 0x53d0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x68(%rbp)
testq %rax, %rax
movss %xmm0, -0x64(%rbp)
js 0x2ae9
movss -0x68(%rbp), %xmm0
movss %xmm0, -0x64(%rbp)
movss -0x64(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
callq 0x5440
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq %rax, -0x70(%rbp)
callq 0x53d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b7a
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x53f0
movq (%rax), %rax
movq %rax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movss -0x34(%rbp), %xmm0
subss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x30(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x34(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
movss -0x30(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x4258f(%rip), %rsi     # 0x450f7
movb $0x4, %al
callq 0x2170
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2afe
movq -0x10(%rbp), %rdi
leaq 0x43276(%rip), %rsi     # 0x45dfb
movb $0x0, %al
callq 0x2170
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/rain/editor_main.cpp
// Function: find_next_sheet(unsigned long long, int)
AssetID find_next_sheet(AssetID start=0, int dir=1) {
    for (s32 i = 1; i < (s32) fog_asset_num(); i++) {
        AssetID curr = (start + i * dir + fog_asset_num()) % fog_asset_num();
        if (fog_asset_is(curr, Type::TEXTURE))
            return curr;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x36ce0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x2c31
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
callq 0x36ce0
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
callq 0x36ce0
movq %rax, %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x36cb0
cmpb $0x0, %al
je 0x2c24
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c39
jmp 0x2c26
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2bb6
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/rain/editor_main.cpp
// Function: create_new_sprite()
void create_new_sprite() {
    EditableSprite new_sprite = {
        std::vector<Vec2>(0),
        find_next_sheet(0, 1),
    };
    read_with_default("sprite name",
            nullptr,
            new_sprite.name,
            MAX_TEXT_LENGTH);

    global_editor.current_sprite = global_editor.sprites.size();
    global_editor.sprites.push_back(new_sprite);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5480
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x54a0
jmp 0x2d13
leaq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x2ba0
movq %rax, -0x60(%rbp)
jmp 0x2d2f
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x5570
movq -0x70(%rbp), %rdx
leaq 0x423a8(%rip), %rdi     # 0x45105
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %ecx
callq 0x2880
jmp 0x2d6d
leaq 0x6704c(%rip), %rdi     # 0x69dc0
movq %rdi, -0x78(%rbp)
callq 0x5590
movq -0x78(%rbp), %rdi
movl %eax, 0x67031(%rip)     # 0x69db8
leaq -0x30(%rbp), %rsi
callq 0x55c0
jmp 0x2d92
leaq -0x30(%rbp), %rdi
callq 0x5630
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2dc7
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x5510
leaq -0x31(%rbp), %rdi
callq 0x5570
jmp 0x2de7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5630
movq -0x40(%rbp), %rdi
callq 0x2310
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/rain/editor_main.cpp
// Function: main
int main(int argc, char *argv[]) {
    fog_input_request_name((u32) In::EDIT_NUM_BINDINGS);
    fog_init(argc, argv);
    setup(argc, argv);

    fog_run(sprite_editor_update, sprite_editor_draw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x12, %edi
callq 0x38400
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x36d30
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2df0
leaq -0x1948(%rip), %rdi     # 0x3a00
leaq -0x6bf(%rip), %rsi      # 0x4c90
callq 0x36d70
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/printf.c
// Function: fctprintf
int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
{
  va_list va;
  va_start(va, format);
  const out_fct_wrap_type out_fct_wrap = { out, arg };
  const int ret = _vsnprintf(_out_fct, (char*)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
  va_end(va);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xb03e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x25(%rip), %rdi        # 0xb0c0
leaq -0x40(%rbp), %rsi
movq $-0x1, %rdx
leaq -0x30(%rbp), %r8
callq 0x9920
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::tweak(char const*, unsigned char*)
b8 tweak(const char *name, b8 *value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %s", name, *value ? "true" : "false");
    debug_value_logic(name, buffer);

    if (name == global_tweak.active && Input::mouse_pressed(0)) {
        *value = !*value;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xe5df
movb $0x0, -0x1(%rbp)
jmp 0xe659
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movb (%rax), %cl
leaq 0x38287(%rip), %rdx     # 0x46877
leaq 0x3827b(%rip), %rax     # 0x46872
cmpb $0x0, %cl
cmovneq %rax, %rdx
leaq 0x38265(%rip), %rdi     # 0x4686a
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rax
leaq 0x5b800(%rip), %rcx     # 0x69e28
cmpq 0x18(%rcx), %rax
jne 0xe655
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
je 0xe655
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xe659
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::tweak(char const*, int*)
b8 tweak(const char *name, s32 *value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %d", name, *value);
    debug_value_logic(name, buffer);

    if (name == global_tweak.hot) {
        s32 delta = moved_over_boundry().x;
        *value += delta;
        return delta != 0;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xe6bf
movb $0x0, -0x1(%rbp)
jmp 0xe725
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x381b7(%rip), %rdi     # 0x46887
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rax
leaq 0x5b735(%rip), %rcx     # 0x69e28
cmpq 0x20(%rcx), %rax
jne 0xe721
callq 0x31440
movq %rax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe725
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::tweak(char const*, unsigned int*)
b8 tweak(const char *name, u32 *value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %u", name, *value);
    debug_value_logic(name, buffer);

    if (name == global_tweak.hot) {
        s32 delta = moved_over_boundry().x;
        if ((s32) *value < -delta) {
            *value = 0;
        } else {
            *value += delta;
        }
        return delta != 0;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xe782
movb $0x0, -0x1(%rbp)
jmp 0xe803
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x380fc(%rip), %rdi     # 0x4688f
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rax
leaq 0x5b672(%rip), %rcx     # 0x69e28
cmpq 0x20(%rcx), %rax
jne 0xe7ff
callq 0x31440
movq %rax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
xorl %ecx, %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jge 0xe7e6
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0xe7f1
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe803
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::tweak(char const*, float*, float)
b8 tweak(const char *name, f32 *value, f32 modifier) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %.4f", name, *value);
    debug_value_logic(name, buffer);

    if (name == global_tweak.hot) {
        f32 delta;
        if (Input::down(TWEAK_STEP)) {
            delta = moved_over_boundry().x;

            if (Input::down(TWEAK_SMOOTH))
                delta *= 0.1;

            if (delta) {
                *value += delta;
                precise_snap(value);
            }
        } else {
            delta = scaled_mouse_movements().x;
            *value += delta * modifier;
        }
        return delta != 0;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xe867
movb $0x0, -0x1(%rbp)
jmp 0xe99b
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x37fff(%rip), %rdi     # 0x4687d
movb $0x1, %al
callq 0x102c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rax
leaq 0x5b587(%rip), %rcx     # 0x69e28
cmpq 0x20(%rcx), %rax
jne 0xe997
leaq 0x700fe(%rip), %rax     # 0x7e9b0
movl (%rax), %edi
movl $0xf, %esi
callq 0x11650
cmpb $0x0, %al
je 0xe94b
callq 0x31440
movq %rax, -0x34(%rbp)
cvtsi2ssl -0x34(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
leaq 0x700cc(%rip), %rax     # 0x7e9ac
movl (%rax), %edi
movl $0xf, %esi
callq 0x11650
cmpb $0x0, %al
je 0xe90e
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3676f(%rip), %xmm1    # 0x45070
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe91f
jp 0xe91f
jmp 0xe949
movss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
movq -0x18(%rbp), %rdi
movss 0x366cc(%rip), %xmm0    # 0x45008
movss 0x368d0(%rip), %xmm1    # 0x45214
callq 0x31500
jmp 0xe97d
callq 0x31410
movlpd %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe99b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::show(char const*, unsigned char)
b8 show(const char *name, b8 value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %s", name, value ? "true" : "false");
    debug_value_logic(name, buffer);
    return name == global_tweak.active && Input::mouse_pressed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xeea1
movb $0x0, -0x1(%rbp)
jmp 0xef09
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %cl
leaq 0x379c8(%rip), %rdx     # 0x46877
leaq 0x379bc(%rip), %rax     # 0x46872
cmpb $0x0, %cl
cmovneq %rax, %rdx
leaq 0x379a6(%rip), %rdi     # 0x4686a
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
leaq 0x5af3f(%rip), %rdx     # 0x69e28
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0xef01
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/tweak_values.cpp
// Function: Util::show(char const*, int)
b8 show(const char *name, s32 value) {
    if (!debug_values_are_on()) return false;
    const char *buffer = Util::format_int(" %s: %d", name, value);
    debug_value_logic(name, buffer);
    return name == global_tweak.active && Input::mouse_pressed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0xf630
cmpb $0x0, %al
jne 0xef6e
movb $0x0, -0x1(%rbp)
jmp 0xefc1
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x3790b(%rip), %rdi     # 0x46887
movb $0x0, %al
callq 0x102c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x312c0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
leaq 0x5ae87(%rip), %rdx     # 0x69e28
cmpq 0x18(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0xefb9
xorl %edi, %edi
callq 0x11c90
cmpb $0x0, %al
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)