LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_wunprot_memory
stm32_err_t stm32_wunprot_memory(const stm32_t *stm)
{
	struct port_interface *port = stm->port;
	stm32_err_t s_err;

	if (stm->cmd->uw == STM32_CMD_ERR) {
		fprintf(stderr, "Error: WRITE UNPROTECT command not implemented in bootloader.\n");
		return STM32_ERR_NO_CMD;
	}

	if (stm32_send_command(stm, stm->cmd->uw) != STM32_ERR_OK)
		return STM32_ERR_UNKNOWN;

	s_err = stm32_get_ack_timeout(stm, STM32_WUNPROT_TIMEOUT);
	if (s_err == STM32_ERR_NACK) {
		fprintf(stderr, "Error: Failed to WRITE UNPROTECT\n");
		return STM32_ERR_UNKNOWN;
	}
	if (s_err != STM32_ERR_OK) {
		if ((port->flags & PORT_STRETCH_W)
		    && stm->cmd->uw != STM32_CMD_UW_NS)
			stm32_warn_stretching("WRITE UNPROTECT");
		return STM32_ERR_UNKNOWN;
	}
	return STM32_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0xff, %eax
jne 0x7acf
movq 0x853e(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x44a6(%rip), %rsi      # 0xbf62
movb $0x0, %al
callq 0x2160
movl $0x3, -0x4(%rbp)
jmp 0x7b6c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x8(%rax), %esi
callq 0x7190
cmpl $0x0, %eax
je 0x7af2
movl $0x1, -0x4(%rbp)
jmp 0x7b6c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x78d0
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x7b2a
movq 0x84e0(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4487(%rip), %rsi      # 0xbfa1
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x7b6c
cmpl $0x0, -0x1c(%rbp)
je 0x7b65
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7b5c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x8(%rax), %eax
cmpl $0x74, %eax
je 0x7b5c
leaq 0x446c(%rip), %rdi      # 0xbfc3
callq 0x79f0
movl $0x1, -0x4(%rbp)
jmp 0x7b6c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_wprot_memory
stm32_err_t stm32_wprot_memory(const stm32_t *stm)
{
	struct port_interface *port = stm->port;
	stm32_err_t s_err;

	if (stm->cmd->wp == STM32_CMD_ERR) {
		fprintf(stderr, "Error: WRITE PROTECT command not implemented in bootloader.\n");
		return STM32_ERR_NO_CMD;
	}

	if (stm32_send_command(stm, stm->cmd->wp) != STM32_ERR_OK)
		return STM32_ERR_UNKNOWN;

	s_err = stm32_get_ack_timeout(stm, STM32_WPROT_TIMEOUT);
	if (s_err == STM32_ERR_NACK) {
		fprintf(stderr, "Error: Failed to WRITE PROTECT\n");
		return STM32_ERR_UNKNOWN;
	}
	if (s_err != STM32_ERR_OK) {
		if ((port->flags & PORT_STRETCH_W)
		    && stm->cmd->wp != STM32_CMD_WP_NS)
			stm32_warn_stretching("WRITE PROTECT");
		return STM32_ERR_UNKNOWN;
	}
	return STM32_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x7(%rax), %eax
cmpl $0xff, %eax
jne 0x7bcf
movq 0x843e(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4417(%rip), %rsi      # 0xbfd3
movb $0x0, %al
callq 0x2160
movl $0x3, -0x4(%rbp)
jmp 0x7c6c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x7(%rax), %esi
callq 0x7190
cmpl $0x0, %eax
je 0x7bf2
movl $0x1, -0x4(%rbp)
jmp 0x7c6c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x78d0
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x7c2a
movq 0x83e0(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x43f6(%rip), %rsi      # 0xc010
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x7c6c
cmpl $0x0, -0x1c(%rbp)
je 0x7c65
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7c5c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x7(%rax), %eax
cmpl $0x64, %eax
je 0x7c5c
leaq 0x43d9(%rip), %rdi      # 0xc030
callq 0x79f0
movl $0x1, -0x4(%rbp)
jmp 0x7c6c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_runprot_memory
stm32_err_t stm32_runprot_memory(const stm32_t *stm)
{
	struct port_interface *port = stm->port;
	stm32_err_t s_err;

	if (stm->cmd->ur == STM32_CMD_ERR) {
		fprintf(stderr, "Error: READOUT UNPROTECT command not implemented in bootloader.\n");
		return STM32_ERR_NO_CMD;
	}

	if (stm32_send_command(stm, stm->cmd->ur) != STM32_ERR_OK)
		return STM32_ERR_UNKNOWN;

	s_err = stm32_get_ack_timeout(stm, STM32_MASSERASE_TIMEOUT);
	if (s_err == STM32_ERR_NACK) {
		fprintf(stderr, "Error: Failed to READOUT UNPROTECT\n");
		return STM32_ERR_UNKNOWN;
	}
	if (s_err != STM32_ERR_OK) {
		if ((port->flags & PORT_STRETCH_W)
		    && stm->cmd->ur != STM32_CMD_UR_NS)
			stm32_warn_stretching("READOUT UNPROTECT");
		return STM32_ERR_UNKNOWN;
	}
	return STM32_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0xff, %eax
jne 0x7ccf
movq 0x833e(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4382(%rip), %rsi      # 0xc03e
movb $0x0, %al
callq 0x2160
movl $0x3, -0x4(%rbp)
jmp 0x7d6e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0xa(%rax), %esi
callq 0x7190
cmpl $0x0, %eax
je 0x7cf2
movl $0x1, -0x4(%rbp)
jmp 0x7d6e
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x78d0
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x7d2a
movq 0x82e0(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4365(%rip), %rsi      # 0xc07f
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x7d6e
cmpl $0x0, -0x1c(%rbp)
je 0x7d67
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7d5e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x93, %eax
je 0x7d5e
leaq 0x434a(%rip), %rdi      # 0xc0a3
callq 0x79f0
movl $0x1, -0x4(%rbp)
jmp 0x7d6e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_readprot_memory
stm32_err_t stm32_readprot_memory(const stm32_t *stm)
{
	struct port_interface *port = stm->port;
	stm32_err_t s_err;

	if (stm->cmd->rp == STM32_CMD_ERR) {
		fprintf(stderr, "Error: READOUT PROTECT command not implemented in bootloader.\n");
		return STM32_ERR_NO_CMD;
	}

	if (stm32_send_command(stm, stm->cmd->rp) != STM32_ERR_OK)
		return STM32_ERR_UNKNOWN;

	s_err = stm32_get_ack_timeout(stm, STM32_RPROT_TIMEOUT);
	if (s_err == STM32_ERR_NACK) {
		fprintf(stderr, "Error: Failed to READOUT PROTECT\n");
		return STM32_ERR_UNKNOWN;
	}
	if (s_err != STM32_ERR_OK) {
		if ((port->flags & PORT_STRETCH_W)
		    && stm->cmd->rp != STM32_CMD_RP_NS)
			stm32_warn_stretching("READOUT PROTECT");
		return STM32_ERR_UNKNOWN;
	}
	return STM32_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x9(%rax), %eax
cmpl $0xff, %eax
jne 0x7dcf
movq 0x823e(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x42f9(%rip), %rsi      # 0xc0b5
movb $0x0, %al
callq 0x2160
movl $0x3, -0x4(%rbp)
jmp 0x7e6e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x9(%rax), %esi
callq 0x7190
cmpl $0x0, %eax
je 0x7df2
movl $0x1, -0x4(%rbp)
jmp 0x7e6e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x78d0
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x7e2a
movq 0x81e0(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x42da(%rip), %rsi      # 0xc0f4
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x7e6e
cmpl $0x0, -0x1c(%rbp)
je 0x7e67
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7e5e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x9(%rax), %eax
cmpl $0x83, %eax
je 0x7e5e
leaq 0x42bd(%rip), %rdi      # 0xc116
callq 0x79f0
movl $0x1, -0x4(%rbp)
jmp 0x7e6e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_mass_erase
static stm32_err_t stm32_mass_erase(const stm32_t *stm)
{
	struct port_interface *port = stm->port;
	stm32_err_t s_err;
	uint8_t buf[3];

	if (stm32_send_command(stm, stm->cmd->er) != STM32_ERR_OK) {
		fprintf(stderr, "Can't initiate chip mass erase!\n");
		return STM32_ERR_UNKNOWN;
	}

	/* regular erase (0x43) */
	if (stm->cmd->er == STM32_CMD_ER) {
		s_err = stm32_send_command_timeout(stm, 0xFF, STM32_MASSERASE_TIMEOUT);
		if (s_err != STM32_ERR_OK) {
			if (port->flags & PORT_STRETCH_W)
				stm32_warn_stretching("mass erase");
			return STM32_ERR_UNKNOWN;
		}
		return STM32_ERR_OK;
	}

	/* extended erase */
	buf[0] = 0xFF;	/* 0xFFFF the magic number for mass erase */
	buf[1] = 0xFF;
	buf[2] = 0x00;  /* checksum */
	if (port->write(port, buf, 3) != PORT_ERR_OK) {
		fprintf(stderr, "Mass erase error.\n");
		return STM32_ERR_UNKNOWN;
	}
	s_err = stm32_get_ack_timeout(stm, STM32_MASSERASE_TIMEOUT);
	if (s_err != STM32_ERR_OK) {
		fprintf(stderr, "Mass erase failed. Try specifying the number of pages to be erased.\n");
		if ((port->flags & PORT_STRETCH_W)
		    && stm->cmd->er != STM32_CMD_EE_NS)
			stm32_warn_stretching("mass erase");
		return STM32_ERR_UNKNOWN;
	}
	return STM32_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x6(%rax), %esi
callq 0x7190
cmpl $0x0, %eax
je 0x8006
movq 0x8007(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x441e(%rip), %rsi      # 0xc411
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x811a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x6(%rax), %eax
cmpl $0x43, %eax
jne 0x8066
movq -0x10(%rbp), %rdi
movl $0xff, %esi
movl $0x23, %edx
callq 0x8d70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x805a
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x804e
leaq 0x43e9(%rip), %rdi      # 0xc432
callq 0x79f0
movl $0x1, -0x4(%rbp)
jmp 0x811a
movl $0x0, -0x4(%rbp)
jmp 0x811a
movb $-0x1, -0x1f(%rbp)
movb $-0x1, -0x1e(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rdi
leaq -0x1f(%rbp), %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x0, %eax
je 0x80af
movq 0x7f5b(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x439e(%rip), %rsi      # 0xc43d
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x811a
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x78d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8113
movq 0x7f23(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4379(%rip), %rsi      # 0xc450
movb $0x0, %al
callq 0x2160
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x810a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x6(%rax), %eax
cmpl $0x45, %eax
je 0x810a
leaq 0x432d(%rip), %rdi      # 0xc432
callq 0x79f0
movl $0x1, -0x4(%rbp)
jmp 0x811a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_go
stm32_err_t stm32_go(const stm32_t *stm, uint32_t address)
{
	struct port_interface *port = stm->port;
	uint8_t buf[5];

	if (stm->cmd->go == STM32_CMD_ERR) {
		fprintf(stderr, "Error: GO command not implemented in bootloader.\n");
		return STM32_ERR_NO_CMD;
	}

	if (stm32_send_command(stm, stm->cmd->go) != STM32_ERR_OK)
		return STM32_ERR_UNKNOWN;

	buf[0] = address >> 24;
	buf[1] = (address >> 16) & 0xFF;
	buf[2] = (address >> 8) & 0xFF;
	buf[3] = address & 0xFF;
	buf[4] = buf[0] ^ buf[1] ^ buf[2] ^ buf[3];
	if (port->write(port, buf, 5) != PORT_ERR_OK)
		return STM32_ERR_UNKNOWN;

	if (stm32_get_ack(stm) != STM32_ERR_OK)
		return STM32_ERR_UNKNOWN;
	return STM32_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x4(%rax), %eax
cmpl $0xff, %eax
jne 0x8532
movq 0x7adb(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x3c3c(%rip), %rsi      # 0xc15b
movb $0x0, %al
callq 0x2160
movl $0x3, -0x4(%rbp)
jmp 0x85e4
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzbl 0x4(%rax), %esi
callq 0x7190
cmpl $0x0, %eax
je 0x8558
movl $0x1, -0x4(%rbp)
jmp 0x85e4
movl -0x14(%rbp), %eax
shrl $0x18, %eax
movb %al, -0x25(%rbp)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x24(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x23(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x22(%rbp)
movzbl -0x25(%rbp), %eax
movzbl -0x24(%rbp), %ecx
xorl %ecx, %eax
movzbl -0x23(%rbp), %ecx
xorl %ecx, %eax
movzbl -0x22(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x25(%rbp), %rsi
movl $0x5, %edx
callq *%rax
cmpl $0x0, %eax
je 0x85c6
movl $0x1, -0x4(%rbp)
jmp 0x85e4
movq -0x10(%rbp), %rdi
callq 0x71f0
cmpl $0x0, %eax
je 0x85dd
movl $0x1, -0x4(%rbp)
jmp 0x85e4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_reset_device
stm32_err_t stm32_reset_device(const stm32_t *stm)
{
	uint32_t target_address = stm->dev->ram_start;

	if (stm->dev->flags & F_OBLL) {
		/* set the OBL_LAUNCH bit to reset device (see RM0360, 2.5) */
		return stm32_run_raw_code(stm, target_address, stm_obl_launch_code, stm_obl_launch_code_length);
	} else if (stm->dev->flags & F_PEMPTY) {
		/* clear the PEMPTY bit to reset the device (see RM0394) */
		return stm32_run_raw_code(stm, target_address, stm_pempty_launch_code, stm_pempty_launch_code_length);
	} else {
		return stm32_run_raw_code(stm, target_address, stm_reset_code, stm_reset_code_length);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x40(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x863a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x3705(%rip), %rdx      # 0xbd30
movl $0x10, %ecx
callq 0x8690
movl %eax, -0x4(%rbp)
jmp 0x8685
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x40(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x866a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x36e5(%rip), %rdx      # 0xbd40
movl $0x38, %ecx
callq 0x8690
movl %eax, -0x4(%rbp)
jmp 0x8685
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x3708(%rip), %rdx      # 0xbd80
movl $0x10, %ecx
callq 0x8690
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_run_raw_code
static stm32_err_t stm32_run_raw_code(const stm32_t *stm,
				      uint32_t target_address,
				      const uint8_t *code, uint32_t code_size)
{
	uint32_t stack_le = le_u32(0x20002000);
	uint32_t code_address_le = le_u32(target_address + 8 + 1); // thumb mode address (!)
	uint32_t length = code_size + 8;
	uint8_t *mem, *pos;
	uint32_t address, w;

	/* Must be 32-bit aligned */
	if (target_address & 0x3) {
		fprintf(stderr, "Error: code address must be 4 byte aligned\n");
		return STM32_ERR_UNKNOWN;
	}

	mem = malloc(length);
	if (!mem)
		return STM32_ERR_UNKNOWN;

	memcpy(mem, &stack_le, sizeof(uint32_t));
	memcpy(mem + 4, &code_address_le, sizeof(uint32_t));
	memcpy(mem + 8, code, code_size);

	pos = mem;
	address = target_address;
	while (length > 0) {
		w = length > 256 ? 256 : length;
		if (stm32_write_memory(stm, address, pos, w) != STM32_ERR_OK) {
			free(mem);
			return STM32_ERR_UNKNOWN;
		}

		address += w;
		pos += w;
		length -= w;
	}

	free(mem);
	return stm32_go(stm, target_address);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x20002000, %edi       # imm = 0x20002000
callq 0x8fc0
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %edi
addl $0x8, %edi
addl $0x1, %edi
callq 0x8fc0
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x86fc
movq 0x7911(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x3e20(%rip), %rsi      # 0xc509
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x87e1
movl -0x30(%rbp), %eax
movl %eax, %edi
callq 0x21b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x871d
movl $0x1, -0x4(%rbp)
jmp 0x87e1
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x2190
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x30(%rbp)
jbe 0x87c9
cmpl $0x100, -0x30(%rbp)     # imm = 0x100
jbe 0x876d
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x4c(%rbp)
jmp 0x8773
movl -0x30(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdx
movl -0x48(%rbp), %ecx
callq 0x75c0
cmpl $0x0, %eax
je 0x87a3
movq -0x38(%rbp), %rdi
callq 0x2030
movl $0x1, -0x4(%rbp)
jmp 0x87e1
movl -0x48(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x48(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x48(%rbp), %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
jmp 0x8754
movq -0x38(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x84e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_sw_crc
uint32_t stm32_sw_crc(uint32_t crc, uint8_t *buf, unsigned int len)
{
	int i;
	uint32_t data;

	if (len & 0x3) {
		fprintf(stderr, "Buffer length must be multiple of 4 bytes\n");
		return 0;
	}

	while (len) {
		data = *buf++;
		data |= *buf++ << 8;
		data |= *buf++ << 16;
		data |= *buf++ << 24;
		len -= 4;

		crc ^= data;

		for (i = 0; i < 32; i++)
			if (crc & CRC_MSBMASK)
				crc = (crc << 1) ^ CRCPOLY_BE;
			else
				crc = (crc << 1);
	}
	return crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x8aa1
movq 0x756c(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x3762(%rip), %rsi      # 0xc1f0
movb $0x0, %al
callq 0x2160
movl $0x0, -0x4(%rbp)
jmp 0x8b6e
jmp 0x8aa3
cmpl $0x0, -0x14(%rbp)
je 0x8b68
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
shll $0x8, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
shll $0x10, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
shll $0x18, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
xorl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x8b63
movl -0x8(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x8b4e
movl -0x8(%rbp), %eax
shll %eax
xorl $0x4c11db7, %eax        # imm = 0x4C11DB7
movl %eax, -0x8(%rbp)
jmp 0x8b56
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0x8(%rbp)
jmp 0x8b58
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8b2c
jmp 0x8aa3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_send_command_timeout
static stm32_err_t stm32_send_command_timeout(const stm32_t *stm,
					      const uint8_t cmd,
					      time_t timeout)
{
	struct port_interface *port = stm->port;
	stm32_err_t s_err;
	port_err_t p_err;
	uint8_t buf[2];

	buf[0] = cmd;
	buf[1] = cmd ^ 0xFF;
	p_err = port->write(port, buf, 2);
	if (p_err != PORT_ERR_OK) {
		fprintf(stderr, "Failed to send command\n");
		return STM32_ERR_UNKNOWN;
	}
	s_err = stm32_get_ack_timeout(stm, timeout);
	if (s_err == STM32_ERR_OK)
		return STM32_ERR_OK;
	if (s_err == STM32_ERR_NACK)
		fprintf(stderr, "Got NACK from device on command 0x%02x\n", cmd);
	else
		fprintf(stderr, "Unexpected reply from device on command 0x%02x\n", cmd);
	return STM32_ERR_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x32(%rbp)
movzbl -0x11(%rbp), %eax
xorl $0xff, %eax
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rdi
leaq -0x32(%rbp), %rsi
movl $0x2, %edx
callq *%rax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x8de5
movq 0x7225(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x34cc(%rip), %rsi      # 0xc2a1
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x8e4b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x78d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x8e04
movl $0x0, -0x4(%rbp)
jmp 0x8e4b
cmpl $0x2, -0x2c(%rbp)
jne 0x8e28
movq 0x71df(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x349a(%rip), %rsi      # 0xc2b9
movb $0x0, %al
callq 0x2160
jmp 0x8e44
movq 0x71c1(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x34a4(%rip), %rsi      # 0xc2e1
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/stm32.c
// Function: stm32_resync
static stm32_err_t stm32_resync(const stm32_t *stm)
{
	struct port_interface *port = stm->port;
	port_err_t p_err;
	uint8_t buf[2], ack;
	time_t t0, t1;

	time(&t0);
	t1 = t0;

	buf[0] = STM32_CMD_ERR;
	buf[1] = STM32_CMD_ERR ^ 0xFF;
	while (t1 < t0 + STM32_RESYNC_TIMEOUT) {
		p_err = port->write(port, buf, 2);
		if (p_err != PORT_ERR_OK) {
			usleep(500000);
			time(&t1);
			continue;
		}
		p_err = port->read(port, &ack, 1);
		if (p_err != PORT_ERR_OK) {
			time(&t1);
			continue;
		}
		if (ack == STM32_NACK)
			return STM32_ERR_OK;
		time(&t1);
	}
	return STM32_ERR_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21a0
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $-0x1, -0x1e(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x23, %rcx
cmpq %rcx, %rax
jge 0x8f26
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
movl $0x2, %edx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8edb
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x22b0
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x8e91
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdi
leaq -0x1f(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8f06
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x8e91
movzbl -0x1f(%rbp), %eax
cmpl $0x1f, %eax
jne 0x8f18
movl $0x0, -0x4(%rbp)
jmp 0x8f2d
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x8e91
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/utils.c
// Function: be_u32
uint32_t be_u32(const uint32_t v) {
	if (cpu_le())
		return	((v & 0xFF000000) >> 24) |
			((v & 0x00FF0000) >>  8) |
			((v & 0x0000FF00) <<  8) |
			((v & 0x000000FF) << 24);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x8f40
cmpb $0x0, %al
je 0x8fae
movl -0x8(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
shrl $0x18, %eax
movl -0x8(%rbp), %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
shrl $0x8, %ecx
orl %ecx, %eax
movl -0x8(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shll $0x8, %ecx
orl %ecx, %eax
movl -0x8(%rbp), %ecx
andl $0xff, %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8fb4
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/utils.c
// Function: printStatus
void printStatus(FILE *fd, int condition){
	if(condition)
		fprintf(fd, "Error!\n");
	else
		fprintf(fd, "OK\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x9049
movq -0x8(%rbp), %rdi
leaq 0x34f5(%rip), %rsi      # 0xc535
movb $0x0, %al
callq 0x2160
jmp 0x905b
movq -0x8(%rbp), %rdi
leaq 0x34e9(%rip), %rsi      # 0xc53d
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/parsers/binary.c
// Function: binary_open
parser_err_t binary_open(void *storage, const char *filename, const char write) {
	binary_t *st = storage;
	if (write) {
		if (filename[0] == '-' && filename[1] == '\0')
			st->fd = 1;
		else
			st->fd = open(
				filename,
#ifndef __WIN32__
				O_WRONLY | O_CREAT | O_TRUNC,
#else
				O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
#endif
#ifndef __WIN32__
				S_IRUSR  | S_IWUSR | S_IRGRP | S_IROTH
#else
				0
#endif
			);
		st->stat.st_size = 0;
	} else {
		if (filename[0] == '-' && filename[1] == '\0') {
			st->fd = 0;
		} else {
			if (stat(filename, &st->stat) != 0)
				return PARSER_ERR_INVALID_FILE;
			st->fd = open(filename,
#ifndef __WIN32__
				O_RDONLY
#else
				O_RDONLY | O_BINARY
#endif
			);
		}
	}

	st->write = write;
	return st->fd == -1 ? PARSER_ERR_SYSTEM : PARSER_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpb $0x0, -0x19(%rbp)
je 0x9103
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x90d8
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x90d8
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
jmp 0x90f5
movq -0x18(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x2220
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x915e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9128
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x9128
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x915c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
callq 0x2180
cmpl $0x0, %eax
je 0x9147
movl $0x2, -0x4(%rbp)
jmp 0x917e
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2220
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x915e
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $-0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/parsers/binary.c
// Function: binary_close
parser_err_t binary_close(void *storage) {
	binary_t *st = storage;

	if (st->fd) close(st->fd);
	free(st);
	return PARSER_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x91b8
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x2120
movq -0x10(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/parsers/binary.c
// Function: binary_read
parser_err_t binary_read(void *storage, void *data, unsigned int *len) {
	binary_t *st = storage;
	unsigned int left = *len;
	unsigned char *d = data;

	if (st->write) return PARSER_ERR_WRONLY;

	ssize_t r;
	while(left > 0) {
		r = read(st->fd, d, left);
		/* If there is no data to read at all, return OK, but with zero read */
		if (r == 0 && left == *len) {
			*len = 0;
			return PARSER_ERR_OK;
		}
		if (r <= 0) return PARSER_ERR_SYSTEM;
		left -= r;
		d += r;
	}

	*len = *len - left;
	return PARSER_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x4(%rax)
je 0x9233
movl $0x3, -0x4(%rbp)
jmp 0x92b9
jmp 0x9235
cmpl $0x0, -0x2c(%rbp)
jbe 0x92a3
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x2130
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x9278
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x9278
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x92b9
cmpq $0x0, -0x40(%rbp)
jg 0x9288
movl $0x1, -0x4(%rbp)
jmp 0x92b9
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x9235
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/parsers/binary.c
// Function: binary_write
parser_err_t binary_write(void *storage, void *data, unsigned int len) {
	binary_t *st = storage;
	unsigned char *d = data;

	if (!st->write) return PARSER_ERR_RDONLY;

	ssize_t r;
	while(len > 0) {
		r = write(st->fd, d, len);
		if (r < 1) return PARSER_ERR_SYSTEM;
		st->stat.st_size += r;

		len  -= r;
		d += r;
	}

	return PARSER_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x4(%rax)
jne 0x9306
movl $0x4, -0x4(%rbp)
jmp 0x9368
jmp 0x9308
cmpl $0x0, -0x1c(%rbp)
jbe 0x9361
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x2090
movq %rax, -0x38(%rbp)
cmpq $0x1, -0x38(%rbp)
jge 0x9336
movl $0x1, -0x4(%rbp)
jmp 0x9368
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9308
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/parsers/hex.c
// Function: hex_close
parser_err_t hex_close(void *storage) {
	hex_t *st = storage;
	if (st) free(st->data);
	free(st);
	return PARSER_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x97f8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/parsers/hex.c
// Function: hex_read
parser_err_t hex_read(void *storage, void *data, unsigned int *len) {
	hex_t *st = storage;
	unsigned int left = st->data_len - st->offset;
	unsigned int get  = left > *len ? *len : left;

	memcpy(data, &st->data[st->offset], get);
	st->offset += get;

	*len = get;
	return PARSER_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x8(%rcx), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x9874
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x987a
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rsi
movl -0x28(%rbp), %eax
movl %eax, %edx
callq 0x2190
movl -0x28(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: combine
aiger* combine(const aiger* monitor, const aiger* implementation) {
    aiger* combination = aiger_init();
    if (combination == NULL) {
        return NULL;
    }
    
    const unsigned offset = monitor->maxvar + 1;
    
    check_signals_defined(monitor, implementation);
    add_inputs_from_monitor(combination, monitor, implementation);
    add_latches_from_monitor(combination, monitor, implementation);
    assert(monitor->num_outputs == 0);
    add_constraints_from_monitor(combination, monitor, implementation);
    import_ands_from_monitor(combination, monitor);
    
    add_latches_from_implementation(combination, implementation, offset);
    import_ands_from_implementation(combination, implementation, offset);
    define_outputs(combination, monitor, implementation, offset);
    return combination;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x22d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x151d
movq $0x0, -0x8(%rbp)
jmp 0x15dd
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1860
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1960
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1564
jmp 0x1583
leaq 0xaba7(%rip), %rdi      # 0xc112
leaq 0xabba(%rip), %rsi      # 0xc12c
movl $0xd1, %edx
leaq 0xabb8(%rip), %rcx      # 0xc136
callq 0x10f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x19f0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bc0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1c30
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1cf0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x1d90
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: add_inputs_from_monitor
static void add_inputs_from_monitor(aiger* combination, const aiger* monitor, const aiger* implementation) {
    for (unsigned i = 0; i < monitor->num_inputs; i++) {
        aiger_symbol input = monitor->inputs[i];
        bool is_output = false;
        for (unsigned j = 0; j < implementation->num_outputs; j++) {
            aiger_symbol impl_output = implementation->outputs[j];
            if (names_do_match(input.name, impl_output.name)) {
                is_output = true;
                break;
            }
        }
        if (is_output) {
            continue;
        }
        aiger_add_input(combination, input.lit, input.name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x1950
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x41(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x192a
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x48(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1ea0
testb $0x1, %al
jne 0x1917
jmp 0x191d
movb $0x1, -0x41(%rbp)
jmp 0x192a
jmp 0x191f
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x18c7
testb $0x1, -0x41(%rbp)
je 0x1932
jmp 0x1942
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x2770
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x187b
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: add_latches_from_monitor
static void add_latches_from_monitor(aiger* combination, const aiger* monitor, const aiger* implementation) {
    for (unsigned i = 0; i < monitor->num_latches; i++) {
        aiger_symbol latch = monitor->latches[i];
        aiger_add_latch(combination, latch.lit, latch.next, latch.name);
        // copy reset value if present
        aiger_add_reset(combination, latch.lit, latch.reset);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x19e5
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x2c90
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x2fb0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x197b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: add_latches_from_implementation
static void add_latches_from_implementation(aiger* combination, const aiger* implementation, const unsigned offset) {
    for (unsigned i = 0; i < implementation->num_latches; i++) {
        aiger_symbol latch = implementation->latches[i];
        latch.lit = translate_literal(implementation, latch.lit, offset);
        latch.next = translate_literal(implementation, latch.next, offset);
        aiger_add_latch(combination, latch.lit, latch.next, latch.name);
        // copy reset value if present
        aiger_add_reset(combination, latch.lit, latch.reset);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x1cdf
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1f70
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1f70
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x2c90
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x2fb0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c4a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: import_ands_from_implementation
static void import_ands_from_implementation(aiger* combination, const aiger* implementation, const unsigned offset) {
    for (unsigned i = 0; i < implementation->num_ands; i++) {
        aiger_and and = implementation->ands[i];
        and.lhs = translate_literal(implementation, and.lhs, offset);
        and.rhs0 = translate_literal(implementation, and.rhs0, offset);
        and.rhs1 = translate_literal(implementation, and.rhs1, offset);
        aiger_add_and(combination, and.lhs, and.rhs0, and.rhs1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x1d88
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x24(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1f70
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1f70
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1f70
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x3a70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d0a
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: define_outputs
static void define_outputs(aiger* combination, const aiger* monitor, const aiger* implementation, const unsigned offset) {
    for (unsigned i = 0; i < monitor->num_inputs; i++) {
        aiger_symbol input = monitor->inputs[i];
        bool is_output = false;
        aiger_symbol output;
        for (unsigned j = 0; j < implementation->num_outputs; j++) {
            output = implementation->outputs[j];
            if (names_do_match(input.name, output.name)) {
                is_output = true;
                break;
            }
        }
        if (!is_output) {
            continue;
        }
        unsigned function = translate_literal(implementation, output.lit, offset);
        aiger_add_and(combination, input.lit, function, 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x1e99
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x41(%rbp)
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x1e5d
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x6c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1ea0
testb $0x1, %al
jne 0x1e4a
jmp 0x1e50
movb $0x1, -0x41(%rbp)
jmp 0x1e5d
jmp 0x1e52
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x1dfa
testb $0x1, -0x41(%rbp)
jne 0x1e65
jmp 0x1e8b
movq -0x18(%rbp), %rdi
movl -0x68(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x1f70
movl %eax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x70(%rbp), %edx
movl $0x1, %ecx
callq 0x3a70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1dae
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: names_do_match
static bool names_do_match(const char* monitor_input, const char* impl_output) {
    const unsigned monitor_input_len = strlen(monitor_input);
    const unsigned impl_output_len = strlen(impl_output);
    const unsigned prefix_len = strlen("AIGER_NEXT_");
    
    if (strncmp(monitor_input, "AIGER_NEXT_", prefix_len) != 0) {
        // special case if input is not contained in LTL formula
        return strcmp(monitor_input, impl_output) == 0;
    }
    assert(monitor_input_len > prefix_len);
    
    if (prefix_len + impl_output_len > monitor_input_len) {
        return false;
    }
    // do a case-insensitive comparision because of different translations
    if (strcasecmp(monitor_input + prefix_len, impl_output) == 0) {
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10b0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10b0
movl %eax, -0x20(%rbp)
movl $0xb, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa2e2(%rip), %rsi      # 0xc1bc
movl $0xb, %edx
callq 0x1070
cmpl $0x0, %eax
je 0x1f03
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f5b
cmpl $0xb, -0x1c(%rbp)
jbe 0x1f0b
jmp 0x1f2a
leaq 0xa2b6(%rip), %rdi      # 0xc1c8
leaq 0xa213(%rip), %rsi      # 0xc12c
movl $0x1b, %edx
leaq 0xa2c2(%rip), %rcx      # 0xc1e7
callq 0x10f0
movl -0x20(%rbp), %eax
addl $0xb, %eax
cmpl -0x1c(%rbp), %eax
jbe 0x1f3b
movb $0x0, -0x1(%rbp)
jmp 0x1f5b
movq -0x10(%rbp), %rdi
addq $0xb, %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x1f57
movb $0x1, -0x1(%rbp)
jmp 0x1f5b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)