LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_lattice_lcmxo2.c
// Function: target_erase
static void target_erase(void)
{
  erase_sram();

  // Enable Flash
  dap_jtag_write_ir(CMD_ISC_ENABLE, IR_LENGTH);
  dap_jtag_write_dr((uint8_t[]){ ISC_ENABLE_FLASH }, 8);
  dap_jtag_idle(8);

  dap_jtag_write_ir(CMD_ISC_ERASE, IR_LENGTH);
  dap_jtag_write_dr((uint8_t[]){ ISC_ERASE_ALL_NV }, 8);
  dap_jtag_idle(8);

  poll_busy_flag();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x10dc0
movl $0xc6, %edi
movl $0x8, %esi
callq 0x8260
movb $0x8, -0x1(%rbp)
leaq -0x1(%rbp), %rdi
movl $0x8, %esi
callq 0x82f0
movl $0x8, %edi
callq 0x81e0
movl $0xe, %edi
movl $0x8, %esi
callq 0x8260
movb $0xe, -0x2(%rbp)
leaq -0x2(%rbp), %rdi
movl $0x8, %esi
callq 0x82f0
movl $0x8, %edi
callq 0x81e0
callq 0x10d20
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_lattice_lcmxo2.c
// Function: poll_busy_flag
static void poll_busy_flag(void)
{
  uint32_t status = 0;
  uint8_t busy = 1;

  while (busy)
  {
    dap_jtag_write_ir(CMD_LSC_CHECK_BUSY, IR_LENGTH);
    dap_jtag_read_dr(&busy, 1);
  }

  dap_jtag_write_ir(CMD_LSC_READ_STATUS, IR_LENGTH);
  dap_jtag_read_dr((uint8_t *)&status, 32);
  dap_jtag_idle(8);

  if (status & STATUS_BUSY)
    error_exit("poll_busy_flag(): busy");

  if (status & STATUS_FAIL)
    error_exit("poll_busy_flag(): fail");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
cmpb $0x0, -0x5(%rbp)
je 0x10d58
movl $0xf0, %edi
movl $0x8, %esi
callq 0x8260
leaq -0x5(%rbp), %rdi
movl $0x1, %esi
callq 0x83a0
jmp 0x10d33
movl $0x3c, %edi
movl $0x8, %esi
callq 0x8260
leaq -0x4(%rbp), %rdi
movl $0x20, %esi
callq 0x83a0
movl $0x8, %edi
callq 0x81e0
movl -0x4(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x10d9a
leaq 0x6aef(%rip), %rdi      # 0x17882
movb $0x0, %al
callq 0x8970
movl -0x4(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x10db5
leaq 0x6aeb(%rip), %rdi      # 0x17899
movb $0x0, %al
callq 0x8970
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_lattice_lcmxo2.c
// Function: erase_sram
static void erase_sram(void)
{
  dap_jtag_write_ir(CMD_ISC_ENABLE, IR_LENGTH);
  dap_jtag_write_dr((uint8_t[]){ ISC_ENABLE_SRAM }, 8);
  dap_jtag_idle(8);

  dap_jtag_write_ir(CMD_ISC_ERASE, IR_LENGTH);
  dap_jtag_write_dr((uint8_t[]){ ISC_ERASE_SRAM }, 8);
  dap_jtag_idle(8);

  dap_jtag_write_ir(CMD_ISC_NOOP, IR_LENGTH);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xc6, %edi
movl $0x8, %esi
callq 0x8260
movb $0x0, -0x1(%rbp)
leaq -0x1(%rbp), %rdi
movl $0x8, %esi
callq 0x82f0
movl $0x8, %edi
callq 0x81e0
movl $0xe, %edi
movl $0x8, %esi
callq 0x8260
movb $0x1, -0x2(%rbp)
leaq -0x2(%rbp), %rdi
movl $0x8, %esi
callq 0x82f0
movl $0x8, %edi
callq 0x81e0
movl $0xff, %edi
movl $0x8, %esi
callq 0x8260
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_lattice_lcmxo2.c
// Function: bitstream_valid
static bool bitstream_valid(uint8_t *data, int size)
{
  if (size < 1024)
    return false;

  if (NULL == mem_find(data, 1024, (uint8_t *)target_device.name, strlen(target_device.name)))
    return false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jge 0x111be
movb $0x0, -0x1(%rbp)
jmp 0x11205
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x71383(%rip), %rax     # 0x82550
movq %rax, -0x20(%rbp)
movq 0x71378(%rip), %rdi     # 0x82550
callq 0x60a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl %eax, %ecx
movl $0x400, %esi            # imm = 0x400
callq 0x8cf0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x11201
movb $0x0, -0x1(%rbp)
jmp 0x11205
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: target_erase
static void target_erase(void)
{
  uint8_t buf[4];
  int cnt = 0;

  buf[0] = FLASH_CMD_CHIP_ERASE;

  flash_write_enable();

  spi_select(0);
  spi_transfer(buf, 1, 1);
  spi_select(1);

  while (flash_is_busy())
  {
    sleep_ms(100);

    if ((cnt++ % 10) == 0)
      verbose(".");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movb $-0x39, -0x4(%rbp)
callq 0x11e10
xorl %edi, %edi
callq 0x11cf0
leaq -0x4(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x11d10
movl $0x1, %edi
callq 0x11cf0
callq 0x11e50
testb $0x1, %al
jne 0x11414
jmp 0x11446
movl $0x64, %edi
callq 0x8a90
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x8(%rbp)
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x11444
leaq 0x3432(%rip), %rdi      # 0x1486f
movb $0x0, %al
callq 0x8630
jmp 0x11409
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: target_program
static void target_program(void)
{
  uint32_t addr = target_options.offset;
  uint32_t offs = 0;
  uint32_t number_of_pages;
  uint8_t *buf = target_options.file_data;
  uint32_t size = target_options.file_size;

  number_of_pages = (size + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;

  for (uint32_t page = 0; page < number_of_pages; page++)
  {
    if (0 == (addr % FLASH_SECTOR_SIZE))
      flash_erase_sector(addr);

    flash_program_page(addr, &buf[offs]);

    addr += FLASH_PAGE_SIZE;
    offs += FLASH_PAGE_SIZE;

    if (0 == (addr % (FLASH_SECTOR_SIZE * STATUS_INTERVAL)))
      verbose(".");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x7110a(%rip), %eax     # 0x825a8
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq 0x71111(%rip), %rax     # 0x825c0
movq %rax, -0x18(%rbp)
movl 0x710ff(%rip), %eax     # 0x825b8
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
subl $0x1, %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x11545
movl -0x4(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x114f3
movl -0x4(%rbp), %edi
callq 0x11eb0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
addq %rax, %rsi
callq 0x11f30
movl -0x4(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x11538
leaq 0x333e(%rip), %rdi      # 0x1486f
movb $0x0, %al
callq 0x8630
jmp 0x1153a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x114d4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: target_read
static void target_read(void)
{
  uint32_t addr = FLASH_ADDR + target_options.offset;
  uint32_t offs = 0;
  uint8_t *buf = target_options.file_data;
  uint32_t size = target_options.size;
  int sector = 0;

  spi_xip_mode();

  while (size)
  {
    dap_read_block(addr, &buf[offs], FLASH_SECTOR_SIZE);

    addr += FLASH_SECTOR_SIZE;
    offs += FLASH_SECTOR_SIZE;
    size -= FLASH_SECTOR_SIZE;

    if (0 == (sector++ % STATUS_INTERVAL))
      verbose(".");
  }

  save_file(target_options.name, buf, target_options.size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x70eda(%rip), %eax     # 0x825a8
addl $0x13000000, %eax       # imm = 0x13000000
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq 0x70edc(%rip), %rax     # 0x825c0
movq %rax, -0x10(%rbp)
movl 0x70ebe(%rip), %eax     # 0x825ac
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x11fd0
cmpl $0x0, -0x14(%rbp)
je 0x11764
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x8(%rbp), %eax
addq %rax, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x7800
movl -0x4(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
subl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %edx, %eax
jne 0x11762
leaq 0x3114(%rip), %rdi      # 0x1486f
movb $0x0, %al
callq 0x8630
jmp 0x116fd
movq 0x70e35(%rip), %rdi     # 0x825a0
movq -0x10(%rbp), %rsi
movl 0x70e37(%rip), %edx     # 0x825ac
callq 0x8c40
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: spi_normal_mode
static void spi_normal_mode(void)
{
  dap_write_word_req(QSPI_SSIENR, 0);
  dap_write_word_req(QSPI_BAUDR, 2);
  dap_write_word_req(QSPI_CTRLR0, QSPI_CTRLR0_SPI_FRF_STD | QSPI_CTRLR0_TMOD_TX_AND_RX | QSPI_CTRLR0_DFS_32(8-1));
  dap_write_word_req(QSPI_SER, 1);
  dap_write_word_req(QSPI_SSIENR, QSPI_SSIENR_SSI_EN);

  // Enable DMA
  dap_write_word_req(QSPI_DMACR, QSPI_DMACR_RDMAE | QSPI_DMACR_TDMAE);

  // Configure RX Channel
  dap_write_word_req(DMA_CH0_READ_ADDR, QSPI_DR0);
  dap_write_word_req(DMA_CH0_CTRL, DMA_CHx_CTRL_EN | DMA_CHx_CTRL_DATA_SIZE_BYTE |
      DMA_CHx_CTRL_INCR_WRITE | DMA_CHx_CTRL_CHAIN_TO(0) |
      DMA_CHx_CTRL_TREQ_SEL(DMA_DREQ_XIP_SSIRX) | DMA_CHx_CTRL_HIGH_PRIORITY);

  // Configure TX Channel
  dap_write_word_req(DMA_CH1_WRITE_ADDR, QSPI_DR0);
  dap_write_word_req(DMA_CH1_CTRL, DMA_CHx_CTRL_EN | DMA_CHx_CTRL_DATA_SIZE_BYTE |
      DMA_CHx_CTRL_INCR_READ | DMA_CHx_CTRL_CHAIN_TO(1) |
      DMA_CHx_CTRL_TREQ_SEL(DMA_DREQ_XIP_SSITX));

  dap_transfer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x18000008, %edi       # imm = 0x18000008
xorl %esi, %esi
callq 0x70c0
movl $0x18000014, %edi       # imm = 0x18000014
movl $0x2, %esi
callq 0x70c0
movl $0x18000000, %edi       # imm = 0x18000000
movl $0x70000, %esi          # imm = 0x70000
callq 0x70c0
movl $0x18000010, %edi       # imm = 0x18000010
movl $0x1, %esi
callq 0x70c0
movl $0x18000008, %edi       # imm = 0x18000008
movl $0x1, %esi
callq 0x70c0
movl $0x1800004c, %edi       # imm = 0x1800004C
movl $0x3, %esi
callq 0x70c0
movl $0x50000014, %edi       # imm = 0x50000014
movl $0x18000060, %esi       # imm = 0x18000060
callq 0x70c0
movl $0x50000010, %edi       # imm = 0x50000010
movl $0x138023, %esi         # imm = 0x138023
callq 0x70c0
movl $0x50000058, %edi       # imm = 0x50000058
movl $0x18000060, %esi       # imm = 0x18000060
callq 0x70c0
movl $0x50000050, %edi       # imm = 0x50000050
movl $0x130811, %esi         # imm = 0x130811
callq 0x70c0
callq 0x6c70
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: spi_transfer
static void spi_transfer(uint8_t *data, int size, int rx_skip)
{
  assert(rx_skip <= size);

  dap_write_block(RAM_ADDR, data, size);

  dap_write_word_req(DMA_CH0_WRITE_ADDR, RAM_HALF_ADDR);
  dap_write_word_req(DMA_CH0_TRANS_COUNT, size);

  dap_write_word_req(DMA_CH1_READ_ADDR, RAM_ADDR);
  dap_write_word_req(DMA_CH1_TRANS_COUNT, size);

  dap_transfer();

  while (dap_read_word(DMA_CH0_CTRL) & DMA_CHx_CTRL_BUSY);

  dap_read_block(RAM_HALF_ADDR + rx_skip, data, size - rx_skip);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x11d2c
jmp 0x11d4b
leaq 0x5ed1(%rip), %rdi      # 0x17c04
leaq 0x5eda(%rip), %rsi      # 0x17c14
movl $0xdc, %edx
leaq 0x5ee2(%rip), %rcx      # 0x17c28
callq 0x60e0
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movl $0x20000000, %edi       # imm = 0x20000000
callq 0x79c0
movl $0x50000018, %edi       # imm = 0x50000018
movl $0x20020000, %esi       # imm = 0x20020000
callq 0x70c0
movl -0xc(%rbp), %esi
movl $0x5000001c, %edi       # imm = 0x5000001C
callq 0x70c0
movl $0x50000054, %edi       # imm = 0x50000054
movl $0x20000000, %esi       # imm = 0x20000000
callq 0x70c0
movl -0xc(%rbp), %esi
movl $0x5000005c, %edi       # imm = 0x5000005C
callq 0x70c0
callq 0x6c70
movl $0x50000010, %edi       # imm = 0x50000010
callq 0x7740
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x11daf
jmp 0x11d99
movl -0x10(%rbp), %edi
addl $0x20020000, %edi       # imm = 0x20020000
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
subl -0x10(%rbp), %edx
callq 0x7800
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: flash_write_enable
static void flash_write_enable(void)
{
  spi_select_req(0);
  dap_write_word_req(QSPI_DR0, FLASH_CMD_WRITE_ENABLE);
  dap_read_word_req(QSPI_DR0);
  spi_select_req(1);
  dap_transfer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x11dd0
movl $0x18000060, %edi       # imm = 0x18000060
movl $0x6, %esi
callq 0x70c0
movl $0x18000060, %edi       # imm = 0x18000060
callq 0x7030
movl $0x1, %edi
callq 0x11dd0
callq 0x6c70
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: flash_is_busy
static bool flash_is_busy(void)
{
  spi_select_req(0);
  dap_write_word_req(QSPI_DR0, FLASH_CMD_READ_STATUS);
  dap_write_word_req(QSPI_DR0, 0);
  dap_read_word_req(QSPI_DR0);
  dap_read_word_req(QSPI_DR0);
  spi_select_req(1);
  dap_transfer();

  return (dap_get_response(4) & 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x11dd0
movl $0x18000060, %edi       # imm = 0x18000060
movl $0x5, %esi
callq 0x70c0
movl $0x18000060, %edi       # imm = 0x18000060
xorl %esi, %esi
callq 0x70c0
movl $0x18000060, %edi       # imm = 0x18000060
callq 0x7030
movl $0x18000060, %edi       # imm = 0x18000060
callq 0x7030
movl $0x1, %edi
callq 0x11dd0
callq 0x6c70
movl $0x4, %edi
callq 0x7690
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: flash_erase_sector
static void flash_erase_sector(int addr)
{
  uint8_t buf[4] = { flash_cmd_sector_erase, (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff };

  flash_write_enable();

  spi_select(0);
  spi_transfer(buf, 4, 4);
  spi_select(1);

  while (flash_is_busy());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0xd837(%rip), %eax      # 0x1f6f8
movb %al, -0x8(%rbp)
movl -0x4(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x7(%rbp)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x6(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0x5(%rbp)
callq 0x11e10
xorl %edi, %edi
callq 0x11cf0
leaq -0x8(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x11d10
movl $0x1, %edi
callq 0x11cf0
callq 0x11e50
testb $0x1, %al
jne 0x11f1c
jmp 0x11f1e
jmp 0x11f11
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: flash_program_page
static void flash_program_page(int addr, uint8_t *data)
{
  uint8_t buf[4 + FLASH_PAGE_SIZE];

  buf[0] = FLASH_CMD_PAGE_PROGRAM;
  buf[1] = addr >> 16;
  buf[2] = addr >> 8;
  buf[3] = addr;

  memcpy(&buf[4], data, FLASH_PAGE_SIZE);

  flash_write_enable();

  spi_select(0);
  spi_transfer(buf, sizeof(buf), sizeof(buf));
  spi_select(1);

  while (flash_is_busy());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x2, -0x120(%rbp)
movl -0x4(%rbp), %eax
sarl $0x10, %eax
movb %al, -0x11f(%rbp)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x11e(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x11d(%rbp)
leaq -0x120(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x61a0
callq 0x11e10
xorl %edi, %edi
callq 0x11cf0
leaq -0x120(%rbp), %rdi
movl $0x104, %edx            # imm = 0x104
movl %edx, %esi
callq 0x11d10
movl $0x1, %edi
callq 0x11cf0
callq 0x11e50
testb $0x1, %al
jne 0x11fb7
jmp 0x11fb9
jmp 0x11fac
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_rpi_rp2040.c
// Function: spi_xip_mode
static void spi_xip_mode(void)
{
  dap_write_word_req(GPIO_QSPI_SS_CTRL, GPIO_QSPI_xx_CTRL_OUTOVER_NORMAL);
  dap_write_word_req(QSPI_SSIENR, 0);
  dap_write_word_req(QSPI_CTRLR0, (flash_quad_mode ? QSPI_CTRLR0_SPI_FRF_QUAD : QSPI_CTRLR0_SPI_FRF_STD) |
      QSPI_CTRLR0_TMOD_EEPROM_READ | QSPI_CTRLR0_DFS_32(32-1));
  dap_write_word_req(QSPI_SPI_CTRLR0, QSPI_SPI_CTRLR0_XIP_CMD(flash_cmd_read_data) |
    QSPI_SPI_CTRLR0_ADDR_L(24 / 4) | QSPI_SPI_CTRLR0_INST_L_8B | QSPI_SPI_CTRLR0_TRANS_TYPE_1C1A |
    QSPI_SPI_CTRLR0_WAIT_CYCLES(flash_wait_cycles));
  dap_write_word_req(QSPI_SSIENR, QSPI_SSIENR_SSI_EN);

  dap_write_word_req(QSPI_DMACR, 0);

  dap_transfer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x4001800c, %edi       # imm = 0x4001800C
xorl %esi, %esi
callq 0x70c0
movl $0x18000008, %edi       # imm = 0x18000008
xorl %esi, %esi
callq 0x70c0
movb 0x705d6(%rip), %cl      # 0x825c8
xorl %esi, %esi
movl $0x400000, %eax         # imm = 0x400000
testb $0x1, %cl
cmovnel %eax, %esi
orl $0x300, %esi            # imm = 0x300
orl $0x1f0000, %esi         # imm = 0x1F0000
movl $0x18000000, %edi       # imm = 0x18000000
callq 0x70c0
movl 0xd6e1(%rip), %esi      # 0x1f6fc
shll $0x18, %esi
orl $0x18, %esi
orl $0x200, %esi            # imm = 0x200
orl $0x0, %esi
movl 0x7059c(%rip), %eax     # 0x825cc
shll $0xb, %eax
orl %eax, %esi
movl $0x180000f4, %edi       # imm = 0x180000F4
callq 0x70c0
movl $0x18000008, %edi       # imm = 0x18000008
movl $0x1, %esi
callq 0x70c0
movl $0x1800004c, %edi       # imm = 0x1800004C
xorl %esi, %esi
callq 0x70c0
callq 0x6c70
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_erase
static void target_erase(void)
{
  dap_write_word_req(FLASH_CR, FLASH_CR_MER);
  dap_write_word_req(FLASH_ADDR, 0);
  dap_transfer();

  flash_wait_done();

  dap_write_word(FLASH_CR, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x4, %esi
callq 0x70c0
movl $0x8000000, %edi        # imm = 0x8000000
xorl %esi, %esi
callq 0x70c0
callq 0x6c70
callq 0x128e0
movl $0x40022014, %edi       # imm = 0x40022014
xorl %esi, %esi
callq 0x77d0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_lock
static void target_lock(void)
{
  uint32_t value = (dap_read_word(OPTIONS_OPTR) & 0xff00) | 0xee;

  dap_write_word_req(FLASH_OPTR, value);
  dap_write_word_req(FLASH_CR, FLASH_CR_OPTSTRT);
  dap_write_word_req(0x40022080, 0);
  dap_transfer();

  flash_wait_done();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1fff0e80, %edi       # imm = 0x1FFF0E80
callq 0x7740
andl $0xff00, %eax           # imm = 0xFF00
orl $0xee, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %esi
movl $0x40022020, %edi       # imm = 0x40022020
callq 0x70c0
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x20000, %esi          # imm = 0x20000
callq 0x70c0
movl $0x40022080, %edi       # imm = 0x40022080
xorl %esi, %esi
callq 0x70c0
callq 0x6c70
callq 0x128e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_program
static void target_program(void)
{
  uint32_t addr = FLASH_ADDR + target_options.offset;
  uint32_t offs = 0;
  uint32_t number_of_pages;
  uint32_t *buf = (uint32_t *)target_options.file_data;
  uint32_t size = target_options.file_size;
  int word_size = FLASH_PAGE_SIZE / sizeof(uint32_t);

  number_of_pages = (size + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;

  for (uint32_t page = 0; page < number_of_pages; page++)
  {
    // Erase Page
    dap_write_word_req(FLASH_CR, FLASH_CR_PER);
    dap_write_word_req(addr, 0);
    dap_transfer();

    flash_wait_done();

    // Program Page
    dap_write_word(FLASH_CR, FLASH_CR_PG);

    for (int i = 0; i < word_size; i++)
    {
      if (i == (word_size-1))
        dap_write_word(FLASH_CR, FLASH_CR_PG | FLASH_CR_PGSTRT);

      dap_write_word_req(addr, buf[offs]);
      addr += sizeof(uint32_t);
      offs++;
    }

    dap_transfer();

    flash_wait_done();

    if (0 == (page % STATUS_INTERVAL))
      verbose(".");
  }

  dap_write_word(FLASH_CR, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x7024a(%rip), %eax     # 0x82608
addl $0x8000000, %eax        # imm = 0x8000000
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq 0x7024c(%rip), %rax     # 0x82620
movq %rax, -0x18(%rbp)
movl 0x7023a(%rip), %eax     # 0x82618
movl %eax, -0x1c(%rbp)
movl $0x20, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x80, %eax
subl $0x1, %eax
shrl $0x7, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x124cd
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x2, %esi
callq 0x70c0
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x70c0
callq 0x6c70
callq 0x128e0
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x1, %esi
callq 0x77d0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x12499
movl -0x28(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x12469
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x80001, %esi          # imm = 0x80001
callq 0x77d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x70c0
movl -0x4(%rbp), %eax
addq $0x4, %rax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x12445
callq 0x6c70
callq 0x128e0
movl -0x24(%rbp), %ecx
andl $0x1f, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x124bd
leaq 0x23b9(%rip), %rdi      # 0x1486f
movb $0x0, %al
callq 0x8630
jmp 0x124bf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12400
movl $0x40022014, %edi       # imm = 0x40022014
xorl %esi, %esi
callq 0x77d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_read
static void target_read(void)
{
  uint32_t addr = FLASH_ADDR + target_options.offset;
  uint32_t offs = 0;
  uint8_t *buf = target_options.file_data;
  uint32_t size = target_options.size;
  int page = 0;

  while (size)
  {
    dap_read_block(addr, &buf[offs], FLASH_PAGE_SIZE);

    addr += FLASH_PAGE_SIZE;
    offs += FLASH_PAGE_SIZE;
    size -= FLASH_PAGE_SIZE;

    if (0 == (page++ % STATUS_INTERVAL))
      verbose(".");
  }

  save_file(target_options.name, buf, target_options.size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x6ffba(%rip), %eax     # 0x82608
addl $0x8000000, %eax        # imm = 0x8000000
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq 0x6ffbc(%rip), %rax     # 0x82620
movq %rax, -0x10(%rbp)
movl 0x6ff9e(%rip), %eax     # 0x8260c
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x126df
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x8(%rbp), %eax
addq %rax, %rsi
movl $0x80, %edx
callq 0x7800
movl -0x4(%rbp), %eax
addl $0x80, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x80, %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
subl $0x80, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl $0x20, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %edx, %eax
jne 0x126dd
leaq 0x2199(%rip), %rdi      # 0x1486f
movb $0x0, %al
callq 0x8630
jmp 0x12678
movq 0x6ff1a(%rip), %rdi     # 0x82600
movq -0x10(%rbp), %rsi
movl 0x6ff1c(%rip), %edx     # 0x8260c
callq 0x8c40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_fuse_read
static int target_fuse_read(int section, uint8_t *data)
{
  uint32_t value;

  if (0 == section)
    value = dap_read_word(OPTIONS_OPTR);
  else if (1 == section)
    value = dap_read_word(OPTIONS_SDKR);
  else if (2 == section)
    value = dap_read_word(OPTIONS_BOOT);
  else if (3 == section)
    value = dap_read_word(OPTIONS_WRPR);
  else
    return 0;

  data[0] = value;
  data[1] = value >> 8;
  data[2] = value >> 16;
  data[3] = value >> 24;

  return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jne 0x12725
movl $0x1fff0e80, %edi       # imm = 0x1FFF0E80
callq 0x7740
movl %eax, -0x14(%rbp)
jmp 0x1277f
movl $0x1, %eax
cmpl -0x8(%rbp), %eax
jne 0x1273e
movl $0x1fff0e84, %edi       # imm = 0x1FFF0E84
callq 0x7740
movl %eax, -0x14(%rbp)
jmp 0x1277d
movl $0x2, %eax
cmpl -0x8(%rbp), %eax
jne 0x12757
movl $0x1fff0e88, %edi       # imm = 0x1FFF0E88
callq 0x7740
movl %eax, -0x14(%rbp)
jmp 0x1277b
movl $0x3, %eax
cmpl -0x8(%rbp), %eax
jne 0x12770
movl $0x1fff0e8c, %edi       # imm = 0x1FFF0E8C
callq 0x7740
movl %eax, -0x14(%rbp)
jmp 0x12779
movl $0x0, -0x4(%rbp)
jmp 0x127be
jmp 0x1277b
jmp 0x1277d
jmp 0x1277f
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: target_fuse_write
static void target_fuse_write(int section, uint8_t *data)
{
  uint32_t value = (data[1] << 8) | data[0];

  if (0 == section)
    dap_write_word_req(FLASH_OPTR, value);
  else if (1 == section)
    dap_write_word_req(FLASH_SDKR, value);
  else if (2 == section)
    dap_write_word_req(FLASH_BTCR, value);
  else if (3 == section)
    dap_write_word_req(FLASH_WRPR, value);
  else
    error_exit("internal: incorrect section index in target_fuse_write()");

  dap_write_word_req(FLASH_CR, FLASH_CR_OPTSTRT);
  dap_write_word_req(0x40022080, 0);
  dap_transfer();

  flash_wait_done();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jne 0x1280c
movl -0x14(%rbp), %esi
movl $0x40022020, %edi       # imm = 0x40022020
callq 0x70c0
jmp 0x1286b
movl $0x1, %eax
cmpl -0x4(%rbp), %eax
jne 0x12825
movl -0x14(%rbp), %esi
movl $0x40022024, %edi       # imm = 0x40022024
callq 0x70c0
jmp 0x12869
movl $0x2, %eax
cmpl -0x4(%rbp), %eax
jne 0x1283e
movl -0x14(%rbp), %esi
movl $0x40022028, %edi       # imm = 0x40022028
callq 0x70c0
jmp 0x12867
movl $0x3, %eax
cmpl -0x4(%rbp), %eax
jne 0x12857
movl -0x14(%rbp), %esi
movl $0x4002202c, %edi       # imm = 0x4002202C
callq 0x70c0
jmp 0x12865
leaq 0x403e(%rip), %rdi      # 0x1689c
movb $0x0, %al
callq 0x8970
jmp 0x12867
jmp 0x12869
jmp 0x1286b
movl $0x40022014, %edi       # imm = 0x40022014
movl $0x20000, %esi          # imm = 0x20000
callq 0x70c0
movl $0x40022080, %edi       # imm = 0x40022080
xorl %esi, %esi
callq 0x70c0
callq 0x6c70
callq 0x128e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/target_puya_py32f0.c
// Function: flash_wait_done
static void flash_wait_done(void)
{
  while (dap_read_word(FLASH_SR) & FLASH_SR_BSY);

  uint32_t sr = dap_read_word(FLASH_SR);

  if (sr & FLASH_SR_ALL_ERRORS)
    error_exit("flash operation failed. FLASH_SR = 0x%08x", sr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40022010, %edi       # imm = 0x40022010
callq 0x7740
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x128fe
jmp 0x128e8
movl $0x40022010, %edi       # imm = 0x40022010
callq 0x7740
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x8010, %eax           # imm = 0x8010
cmpl $0x0, %eax
je 0x12929
movl -0x4(%rbp), %esi
leaq 0x4b7f(%rip), %rdi      # 0x174a1
movb $0x0, %al
callq 0x8970
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dbg_lin.c
// Function: dbg_open
void dbg_open(debugger_t *debugger, int version)
{
  g_debugger = debugger;

  g_debugger_fd = open(g_debugger->path, O_RDWR);

  if (g_debugger_fd < 0)
    error_exit("unable to open device %s: %s",  g_debugger->path, strerror(errno));

  g_debugger->use_v2 = (DBG_CMSIS_DAP_V2 == version);

  int interface = g_debugger->use_v2 ? g_debugger->v2_interface : g_debugger->v1_interface;

  { // Disconnect kernel driver
    struct usbdevfs_disconnect_claim dc;

    dc.interface = interface;
    dc.flags = USBDEVFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
    strcpy(dc.driver, "usbfs");

    int res = ioctl(g_debugger_fd, USBDEVFS_DISCONNECT_CLAIM, &dc);
    check(res >= 0, "ioctl(DISCONNECT_CLAIM): %d", res);
  }

  { // Claim interface
    int res = ioctl(g_debugger_fd, USBDEVFS_CLAIMINTERFACE, &interface);
    check(res >= 0, "ioctl(CLAIMINTERFACE): %d", res);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x6f77b(%rip)     # 0x82628
movq 0x6f774(%rip), %rax     # 0x82628
movq (%rax), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x6210
movl %eax, 0xc9c7(%rip)      # 0x1f890
cmpl $0x0, 0xc9c0(%rip)      # 0x1f890
jge 0x12f07
movq 0x6f74f(%rip), %rax     # 0x82628
movq (%rax), %rax
movq %rax, -0x128(%rbp)
callq 0x6040
movl (%rax), %edi
callq 0x62a0
movq -0x128(%rbp), %rsi
movq %rax, %rdx
leaq 0x4e82(%rip), %rdi      # 0x17d82
movb $0x0, %al
callq 0x8970
movl $0x4, %eax
cmpl -0xc(%rbp), %eax
sete %cl
movq 0x6f70f(%rip), %rax     # 0x82628
andb $0x1, %cl
movb %cl, 0x34(%rax)
movq 0x6f702(%rip), %rax     # 0x82628
testb $0x1, 0x34(%rax)
je 0x12f3e
movq 0x6f6f5(%rip), %rax     # 0x82628
movl 0x58(%rax), %eax
movl %eax, -0x12c(%rbp)
jmp 0x12f4e
movq 0x6f6e3(%rip), %rax     # 0x82628
movl 0x40(%rax), %eax
movl %eax, -0x12c(%rbp)
movl -0x12c(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x118(%rbp)
movl $0x2, -0x114(%rbp)
leaq -0x118(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4e23(%rip), %rsi      # 0x17d9f
callq 0x6050
movl 0xc909(%rip), %edi      # 0x1f890
movl $0x8108551b, %esi       # imm = 0x8108551B
leaq -0x118(%rbp), %rdx
movb $0x0, %al
callq 0x6100
movl %eax, -0x11c(%rbp)
cmpl $0x0, -0x11c(%rbp)
setge %al
movl -0x11c(%rbp), %edx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x4de8(%rip), %rsi      # 0x17da5
xorl %eax, %eax
callq 0x8880
movl 0xc8c6(%rip), %edi      # 0x1f890
movl $0x8004550f, %esi       # imm = 0x8004550F
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x6100
movl %eax, -0x120(%rbp)
cmpl $0x0, -0x120(%rbp)
setge %al
movl -0x120(%rbp), %edx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x4dc4(%rip), %rsi      # 0x17dc1
xorl %eax, %eax
callq 0x8880
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dbg_lin.c
// Function: dbg_close
void dbg_close(void)
{
  int interface = g_debugger->use_v2 ? g_debugger->v2_interface : g_debugger->v1_interface;

  { // Release interface
    int res = ioctl(g_debugger_fd, USBDEVFS_RELEASEINTERFACE, &interface);
    check(res >= 0, "ioctl(RELEASEINTERFACE): %d", res);
  }

  close(g_debugger_fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x6f609(%rip), %rax     # 0x82628
testb $0x1, 0x34(%rax)
je 0x13034
movq 0x6f5fc(%rip), %rax     # 0x82628
movl 0x58(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x13041
movq 0x6f5ed(%rip), %rax     # 0x82628
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0xc843(%rip), %edi      # 0x1f890
movl $0x80045510, %esi       # imm = 0x80045510
leaq -0x4(%rbp), %rdx
movb $0x0, %al
callq 0x6100
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
setge %al
movl -0x8(%rbp), %edx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x4d64(%rip), %rsi      # 0x17ddb
xorl %eax, %eax
callq 0x8880
movl 0xc80c(%rip), %edi      # 0x1f890
callq 0x6130
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dbg_lin.c
// Function: find_descriptor
static void *find_descriptor(uint8_t **desc, int *size, int desc_type, int desc_size)
{
  while (*size >= desc_size)
  {
    struct usb_descriptor_header *hdr = (struct usb_descriptor_header *)*desc;

    *desc += hdr->bLength;
    *size -= hdr->bLength;

    if (hdr->bDescriptorType == desc_type)
      return hdr;
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x20(%rbp), %eax
jl 0x13499
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x13497
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x134a1
jmp 0x13442
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dbg_lin.c
// Function: get_string
static char *get_string(int fd, int index)
{
  struct usbdevfs_ctrltransfer ctrl;
  uint16_t buf[128] = { 0 };

  ctrl.bRequestType = USB_RECIP_DEVICE | USB_TYPE_STANDARD | USB_DIR_IN;
  ctrl.bRequest     = USB_REQ_GET_DESCRIPTOR;
  ctrl.wValue       = (USB_DT_STRING << 8) | index;
  ctrl.wIndex       = LANGID_US_ENGLISH;
  ctrl.wLength      = sizeof(buf);
  ctrl.data         = buf;
  ctrl.timeout      = CONTROL_TIMEOUT;

  int res = ioctl(fd, USBDEVFS_CONTROL, &ctrl);

  if (res < 0)
    return "";

  check(res >= 2 && 0 == (res % 2), "invalid string descriptor response");

  int len = res/2 - 1;
  char *str = "<unknown>";

  if (len > 0)
  {
    str = buf_alloc(len + 1);

    for (int i = 0; i < len; i++)
      str[i] = isprint(buf[i+1]) ? buf[i+1] : '?';
  }

  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x60f0
movb $-0x80, -0x28(%rbp)
movb $0x6, -0x27(%rbp)
movl -0x10(%rbp), %eax
orl $0x300, %eax            # imm = 0x300
movw %ax, -0x26(%rbp)
movw $0x409, -0x24(%rbp)     # imm = 0x409
movw $0x100, -0x22(%rbp)     # imm = 0x100
leaq -0x130(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x96, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl $0xc0185500, %esi       # imm = 0xC0185500
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x6100
movl %eax, -0x134(%rbp)
cmpl $0x0, -0x134(%rbp)
jge 0x13538
leaq 0x140e(%rip), %rax      # 0x1493d
movq %rax, -0x8(%rbp)
jmp 0x13670
xorl %eax, %eax
cmpl $0x2, -0x134(%rbp)
movb %al, -0x145(%rbp)
jl 0x13564
movl -0x134(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %edx, %eax
sete %al
movb %al, -0x145(%rbp)
movb -0x145(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x4973(%rip), %rsi      # 0x17eea
xorl %eax, %eax
callq 0x8880
movl -0x134(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x1, %eax
movl %eax, -0x138(%rbp)
leaq 0x4971(%rip), %rax      # 0x17f0d
movq %rax, -0x140(%rbp)
cmpl $0x0, -0x138(%rbp)
jle 0x13665
movl -0x138(%rbp), %edi
addl $0x1, %edi
callq 0x8ae0
movq %rax, -0x140(%rbp)
movl $0x0, -0x144(%rbp)
movl -0x144(%rbp), %eax
cmpl -0x138(%rbp), %eax
jge 0x13663
callq 0x62d0
movq (%rax), %rax
movl -0x144(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzwl -0x130(%rbp,%rcx,2), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x13629
movl -0x144(%rbp), %eax
addl $0x1, %eax
cltq
movzwl -0x130(%rbp,%rax,2), %eax
movl %eax, -0x14c(%rbp)
jmp 0x13636
movl $0x3f, %eax
movl %eax, -0x14c(%rbp)
jmp 0x13636
movl -0x14c(%rbp), %eax
movb %al, %dl
movq -0x140(%rbp), %rax
movslq -0x144(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x135cf
jmp 0x13665
movq -0x140(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/bar_pair.c
// Function: main
int
main()
{
    int me;
    int i;

    for (i = 0; i < SHMEM_BARRIER_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_init();
    me = shmem_my_pe();

    shmem_barrier_all();

    if (me == 0) {
        shmem_int_p(&x, 4, 1);
    }

    if (me == 2) {
        printf("Process %d going to sleep\n", me);
        sleep(3);
        printf("Process %d out from sleep\n", me);
    }

    printf("Process %d before barrier\n", me);
    if (me == 2 || me == 3) {
        shmem_barrier(2, 0, 2, pSync);
    }
    printf("Process %d after barrier\n", me);

    printf("%d: x = %d\n", me, x);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jge 0x11ec
movslq 0xc(%rsp), %rcx
leaq 0x2ea1(%rip), %rax      # 0x4078
movq $-0x1, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11c4
callq 0x10a0
callq 0x1080
movl %eax, 0x10(%rsp)
callq 0x1090
cmpl $0x0, 0x10(%rsp)
jne 0x121c
leaq 0x2e5b(%rip), %rdi      # 0x4068
movl $0x4, %esi
movl $0x1, %edx
callq 0x1040
cmpl $0x2, 0x10(%rsp)
jne 0x1251
movl 0x10(%rsp), %esi
leaq 0xdd6(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x3, %edi
callq 0x1060
movl 0x10(%rsp), %esi
leaq 0xdd5(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1030
movl 0x10(%rsp), %esi
leaq 0xdde(%rip), %rdi       # 0x203a
movb $0x0, %al
callq 0x1030
cmpl $0x2, 0x10(%rsp)
je 0x1271
cmpl $0x3, 0x10(%rsp)
jne 0x1286
movl $0x2, %edx
xorl %esi, %esi
leaq 0x2df9(%rip), %rcx      # 0x4078
movl %edx, %edi
callq 0x1050
movl 0x10(%rsp), %esi
leaq 0xdc4(%rip), %rdi       # 0x2055
movb $0x0, %al
callq 0x1030
movl 0x10(%rsp), %esi
movl 0x2dc6(%rip), %edx      # 0x4068
leaq 0xdc6(%rip), %rdi       # 0x206f
movb $0x0, %al
callq 0x1030
callq 0x1070
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/read1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[FILESIZE];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	unlink(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));

	while (1) {
		int len = read(fd, buf, BUFLEN);
		assert(len >= 0);
		if (len == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100040, %rsp         # imm = 0x100040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1326(%rip), %rax      # 0x4300
movq %rax, -0x100030(%rbp)
movq 0x1320(%rip), %rax      # 0x4308
movq %rax, -0x100028(%rbp)
movq 0x131a(%rip), %rax      # 0x4310
movq %rax, -0x100020(%rbp)
leaq -0x100030(%rbp), %rdi
callq 0x21d0
movl %eax, -0x100034(%rbp)
leaq -0x100030(%rbp), %rdi
callq 0x2080
leaq -0x100010(%rbp), %rdi
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x2130
cmpl $0x0, -0x100034(%rbp)
jl 0x3039
jmp 0x3058
leaq 0x123b(%rip), %rdi      # 0x427b
leaq 0x123c(%rip), %rsi      # 0x4283
movl $0x15, %edx
leaq 0x123e(%rip), %rcx      # 0x4291
callq 0x2120
movl -0x100034(%rbp), %edi
leaq -0x100010(%rbp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20c0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x3079
jmp 0x3098
leaq 0x1244(%rip), %rdi      # 0x42c4
leaq 0x11fc(%rip), %rsi      # 0x4283
movl $0x16, %edx
leaq 0x11fe(%rip), %rcx      # 0x4291
callq 0x2120
jmp 0x309a
movl -0x100034(%rbp), %edi
leaq -0x100010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2150
movl %eax, -0x100038(%rbp)
cmpl $0x0, -0x100038(%rbp)
jl 0x30c2
jmp 0x30e1
leaq 0x1226(%rip), %rdi      # 0x42ef
leaq 0x11b3(%rip), %rsi      # 0x4283
movl $0x1a, %edx
leaq 0x11b5(%rip), %rcx      # 0x4291
callq 0x2120
cmpl $0x0, -0x100038(%rbp)
jne 0x30fb
movl -0x100034(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x309a
// File: /workspace/github_c_makefile_star2_O0/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_right
int		check_right(t_map *map, int x, int y)
{
	int	i;
	int	test;

	i = 0;
	test = 0;
	while ((y + i) < map->width_map && (map->mapp[x][y + i] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x][y + i]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x][y + i] == '1')
			test = 1;
		i++;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x21(%rbp)
jge 0x75c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x75d2
jmp 0x764f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
leaq 0xaa13(%rip), %rdi      # 0x12004
movsbl (%rax,%rcx), %esi
callq 0xe5f0
cmpl $0x0, %eax
jne 0x7619
leaq 0xaa06(%rip), %rdi      # 0x1200c
leaq 0xaa05(%rip), %rsi      # 0x12012
callq 0xf060
xorl %edi, %edi
callq 0x70a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x7641
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7590
cmpl $0x1, -0x20(%rbp)
jne 0x765e
movl $0x1, -0x4(%rbp)
jmp 0x7665
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_left
int		check_left(t_map *map, int x, int y)
{
	int	test;

	test = 0;
	while (y >= 0 && (map->mapp[x][y] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x][y]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x][y] == '1')
			test = 1;
		y--;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
jl 0x76b4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x76bd
jmp 0x7730
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
leaq 0xa92d(%rip), %rdi      # 0x12004
movsbl (%rax,%rcx), %esi
callq 0xe5f0
cmpl $0x0, %eax
jne 0x76ff
leaq 0xa920(%rip), %rdi      # 0x1200c
leaq 0xa91f(%rip), %rsi      # 0x12012
callq 0xf060
xorl %edi, %edi
callq 0x70a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x7722
movl $0x1, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7689
cmpl $0x1, -0x1c(%rbp)
jne 0x773f
movl $0x1, -0x4(%rbp)
jmp 0x7746
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_above
int		check_above(t_map *map, int x, int y)
{
	int	i;
	int	test;

	i = 0;
	test = 0;
	while ((x + i) <= map->height_map && (map->mapp[x + i][y] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x + i][y]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x + i][y] == '1')
			test = 1;
		i++;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x21(%rbp)
jg 0x77a9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x77b2
jmp 0x782f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
leaq 0xa833(%rip), %rdi      # 0x12004
movsbl (%rax,%rcx), %esi
callq 0xe5f0
cmpl $0x0, %eax
jne 0x77f9
leaq 0xa826(%rip), %rdi      # 0x1200c
leaq 0xa825(%rip), %rsi      # 0x12012
callq 0xf060
xorl %edi, %edi
callq 0x70a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x7821
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7770
cmpl $0x1, -0x20(%rbp)
jne 0x783e
movl $0x1, -0x4(%rbp)
jmp 0x7845
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/florianne1212[P]Cub3D_42/srcs/check.c
// Function: check_below
int		check_below(t_map *map, int x, int y)
{
	int	test;

	test = 0;
	while ((x) >= 0 && (map->mapp[x][y] != 32))
	{
		if (ft_strcmp_c("012NSWE", map->mapp[x][y]) == 0)
		{
			put_color(RED,
			"\nError\n wrong character in map or too many elements");
			exit(0);
		}
		if (map->mapp[x][y] == '1')
			test = 1;
		x--;
	}
	if (test == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x1d(%rbp)
jl 0x7894
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x789d
jmp 0x7910
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
leaq 0xa74d(%rip), %rdi      # 0x12004
movsbl (%rax,%rcx), %esi
callq 0xe5f0
cmpl $0x0, %eax
jne 0x78df
leaq 0xa740(%rip), %rdi      # 0x1200c
leaq 0xa73f(%rip), %rsi      # 0x12012
callq 0xf060
xorl %edi, %edi
callq 0x70a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0x7902
movl $0x1, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7869
cmpl $0x1, -0x1c(%rbp)
jne 0x791f
movl $0x1, -0x4(%rbp)
jmp 0x7926
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop