LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch3/eatyguy3.c
// Function: set_pos
int set_pos(lua_State *L) {
  int x = lua_tonumber(L, 1);
  int y = lua_tonumber(L, 2);
  char cmd[1024];
  // The 'tput cup' command accepts y before x; not a typo.
  snprintf(cmd, 1024, "tput cup %d %d", y, x);
  system(cmd);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6660
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6660
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
movl $0x400, %esi            # imm = 0x400
leaq 0x2e785(%rip), %rdx     # 0x34090
movb $0x0, %al
callq 0x5190
leaq -0x410(%rbp), %rdi
callq 0x5160
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_verify.c
// Function: check_flags
static inline int check_flags(int ref, int res)
{
    if (PARASAIL_FLAG_NW & ref)
        return PARASAIL_FLAG_NW & res;
    else if (PARASAIL_FLAG_SG & ref)
        return PARASAIL_FLAG_SG & res;
    else if (PARASAIL_FLAG_SW & ref)
        return PARASAIL_FLAG_SW & res;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x151bf0
movl -0xc(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x151c23
movl -0x8(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x151c06
movl -0xc(%rbp), %eax
andl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x151c23
movl -0x8(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x151c1c
movl -0xc(%rbp), %eax
andl $0x4, %eax
movl %eax, -0x4(%rbp)
jmp 0x151c23
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/apps/parasail_stats.c
// Function: print_help
static void print_help(const char *progname, int status) {
    fprintf(stderr, "\nusage: %s "
            "file "
            "\n\n",
            progname);
    exit(status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x3c22(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1d2b(%rip), %rsi      # 0x310f
movb $0x0, %al
callq 0x10a0
movl -0xc(%rbp), %edi
callq 0x1110
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/millimat[P]Soft-Heap/epsilon-timing.c
// Function: main
int main(int argc, char *argv[]) {
  int n = 10000;
  int tries = 10;

  srand(time(NULL));

  time_insert_extract(tries, n);
  time_meld(tries, n);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2710, -0x14(%rbp)    # imm = 0x2710
movl $0xa, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1080
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x11e0
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x1580
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/i2c.c
// Function: i2c_close
static port_err_t i2c_close(struct port_interface *port)
{
	struct i2c_priv *h;

	h = (struct i2c_priv *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;
	close(h->fd);
	free(h);
	port->private = NULL;
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2618
movl $0x3, -0x4(%rbp)
jmp 0x263f
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/i2c.c
// Function: i2c_read
static port_err_t i2c_read(struct port_interface *port, void *buf,
			   size_t nbyte)
{
	struct i2c_priv *h;
	int ret;

	h = (struct i2c_priv *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;
	ret = read(h->fd, buf, nbyte);
	if (ret != (int)nbyte)
		return PORT_ERR_UNKNOWN;
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2690
movl $0x3, -0x4(%rbp)
jmp 0x26c1
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2130
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
je 0x26ba
movl $0x3, -0x4(%rbp)
jmp 0x26c1
movl $0x0, -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/i2c.c
// Function: i2c_write
static port_err_t i2c_write(struct port_interface *port, void *buf,
			    size_t nbyte)
{
	struct i2c_priv *h;
	int ret;

	h = (struct i2c_priv *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;
	ret = write(h->fd, buf, nbyte);
	if (ret != (int)nbyte)
		return PORT_ERR_UNKNOWN;
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2700
movl $0x3, -0x4(%rbp)
jmp 0x2731
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2090
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
je 0x272a
movl $0x3, -0x4(%rbp)
jmp 0x2731
movl $0x0, -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/i2c.c
// Function: i2c_get_cfg_str
static const char *i2c_get_cfg_str(struct port_interface *port)
{
	struct i2c_priv *h;
	static char str[11];

	h = (struct i2c_priv *)port->private;
	if (h == NULL)
		return "INVALID";
	snprintf(str, sizeof(str), "addr 0x%2x", h->addr);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x278c
leaq 0x7ce2(%rip), %rax      # 0xa468
movq %rax, -0x8(%rbp)
jmp 0x27b8
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0xdbf7(%rip), %rdi      # 0x10391
movl $0xb, %esi
leaq 0x7cca(%rip), %rdx      # 0xa470
movb $0x0, %al
callq 0x20e0
leaq 0xdbdd(%rip), %rax      # 0x10391
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/init.c
// Function: gpio_bl_exit
int gpio_bl_exit(struct port_interface *port, const char *seq)
{
	char *s;

	if (seq == NULL)
		return 1;

	s = strchr(seq, ':');
	if (s == NULL || s[1] == '\0')
		return 1;

	return gpio_sequence(port, s + 1, strlen(s + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27f0
movl $0x1, -0x4(%rbp)
jmp 0x2853
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x20d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2816
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x281f
movl $0x1, -0x4(%rbp)
jmp 0x2853
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x20b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2860
movl %eax, -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/init.c
// Function: gpio_bl_entry
static int gpio_bl_entry(struct port_interface *port, const char *seq)
{
	char *s;

	if (seq == NULL || seq[0] == ':')
		return 1;

	s = strchr(seq, ':');
	if (s == NULL)
		return gpio_sequence(port, seq, strlen(seq));

	return gpio_sequence(port, seq, s - seq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d23
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x2d2c
movl $0x1, -0x4(%rbp)
jmp 0x2d8e
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x20d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2d73
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2860
movl %eax, -0x4(%rbp)
jmp 0x2d8e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x2860
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/init.c
// Function: release_gpio
static int release_gpio(int n, int input, int exported)
{
	char num[16]; /* sized to carry MAX_INT */
	char file[48]; /* sized to carry longest filename */

	sprintf(num, "%d", n);
	if (input) {
		sprintf(file, "/sys/class/gpio/gpio%d/direction", n);
		write_to(file, "in");
	}
	if (!exported)
		write_to("/sys/class/gpio/unexport", num);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x8a44(%rip), %rsi      # 0xba93
movb $0x0, %al
callq 0x2280
cmpl $0x0, -0x8(%rbp)
je 0x3081
leaq -0x50(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x7529(%rip), %rsi      # 0xa593
movb $0x0, %al
callq 0x2280
leaq -0x50(%rbp), %rdi
leaq 0x759f(%rip), %rsi      # 0xa61b
callq 0x30b0
cmpl $0x0, -0xc(%rbp)
jne 0x3097
leaq -0x20(%rbp), %rsi
leaq 0x758c(%rip), %rdi      # 0xa61e
callq 0x30b0
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/init.c
// Function: write_to
static int write_to(const char *filename, const char *value)
{
	int fd, ret;

	fd = open(filename, O_WRONLY);
	if (fd < 0) {
		fprintf(stderr, "Cannot open file \"%s\"\n", filename);
		return 0;
	}
	ret = write(fd, value, strlen(value));
	if (ret < 0) {
		fprintf(stderr, "Error writing in file \"%s\"\n", filename);
		close(fd);
		return 0;
	}
	close(fd);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x2220
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x30fe
movq 0xcf10(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x74de(%rip), %rsi      # 0xa5cc
movb $0x0, %al
callq 0x2160
movl $0x0, -0x4(%rbp)
jmp 0x3169
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2090
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x315a
movq 0xcebc(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x74a1(%rip), %rsi      # 0xa5e3
movb $0x0, %al
callq 0x2160
movl -0x1c(%rbp), %edi
callq 0x2120
movl $0x0, -0x4(%rbp)
jmp 0x3169
movl -0x1c(%rbp), %edi
callq 0x2120
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/init.c
// Function: read_from
static int read_from(const char *filename, char *buf, size_t len)
{
	int fd, ret;
	size_t n = 0;

	fd = open(filename, O_RDONLY);
	if (fd < 0) {
		fprintf(stderr, "Cannot open file \"%s\"\n", filename);
		return 0;
	}

	do {
		ret = read(fd, buf + n, len - n);
		if (ret < 0) {
			if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
				continue; /* try again */
			fprintf(stderr, "Error reading in file \"%s\"\n", filename);
			close(fd);
			return 0;
		}
		n += ret;
	} while (n < len && ret);

	close(fd);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2220
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x31da
movq 0xce37(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x7405(%rip), %rsi      # 0xa5cc
movb $0x0, %al
callq 0x2160
movl $0x0, -0x4(%rbp)
jmp 0x3289
jmp 0x31dc
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x2130
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x324a
callq 0x2040
cmpl $0x4, (%rax)
je 0x321b
callq 0x2040
cmpl $0xb, (%rax)
je 0x321b
callq 0x2040
cmpl $0xb, (%rax)
jne 0x321d
jmp 0x3256
movq 0xcdcc(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x73cd(%rip), %rsi      # 0xa5ff
movb $0x0, %al
callq 0x2160
movl -0x24(%rbp), %edi
callq 0x2120
movl $0x0, -0x4(%rbp)
jmp 0x3289
movslq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x326f
cmpl $0x0, -0x28(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x31dc
movl -0x24(%rbp), %edi
callq 0x2120
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/main.c
// Function: flash_addr_to_page_ceil
int flash_addr_to_page_ceil(uint32_t addr)
{
	int page;
	uint32_t *psize;

	if (!(addr >= stm->dev->fl_start && addr <= stm->dev->fl_end))
		return 0;

	page = 0;
	addr -= stm->dev->fl_start;
	psize = stm->dev->fl_ps;

	while (addr >= psize[0]) {
		addr -= psize[0];
		page++;
		if (psize[1])
			psize++;
	}

	return addr ? page + 1 : page;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq 0xd0ef(%rip), %rcx      # 0x103a0
movq 0x20(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jb 0x32cd
movl -0x8(%rbp), %eax
movq 0xd0dc(%rip), %rcx      # 0x103a0
movq 0x20(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0x32d9
movl $0x0, -0x4(%rbp)
jmp 0x3360
movl $0x0, -0xc(%rbp)
movq 0xd0b9(%rip), %rax      # 0x103a0
movq 0x20(%rax), %rax
movl 0x18(%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0xd0a3(%rip), %rax      # 0x103a0
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x3343
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x3341
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x3309
cmpl $0x0, -0x8(%rbp)
je 0x3354
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x335a
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/main.c
// Function: sighandler
void sighandler(int s){
	fprintf(stderr, "\nCaught signal %d\n",s);
	if (p_st &&  parser ) parser->close(p_st);
	if (stm  ) stm32_close  (stm);
	if (port) port->close(port);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xcc6e(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x73b5(%rip), %rsi      # 0xa744
movb $0x0, %al
callq 0x2160
cmpq $0x0, 0xd00a(%rip)      # 0x103a8
je 0x33be
cmpq $0x0, 0xd008(%rip)      # 0x103b0
je 0x33be
movq 0xcfff(%rip), %rax      # 0x103b0
movq 0x18(%rax), %rax
movq 0xcfec(%rip), %rdi      # 0x103a8
callq *%rax
cmpq $0x0, 0xcfda(%rip)      # 0x103a0
je 0x33d4
movq 0xcfd1(%rip), %rdi      # 0x103a0
callq 0x71c0
cmpq $0x0, 0xcfdc(%rip)      # 0x103b8
je 0x33f2
movq 0xcfd3(%rip), %rax      # 0x103b8
movq 0x18(%rax), %rax
movq 0xcfc8(%rip), %rdi      # 0x103b8
callq *%rax
movl $0x1, %edi
callq 0x2290
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/./parsers/parser.h
// Function: parser_errstr
static inline const char* parser_errstr(parser_err_t err) {
	switch(err) {
		case PARSER_ERR_OK          : return "OK";
		case PARSER_ERR_SYSTEM      : return "System Error";
		case PARSER_ERR_INVALID_FILE: return "Invalid File";
		case PARSER_ERR_WRONLY      : return "Parser can only write";
		case PARSER_ERR_RDONLY      : return "Parser can only read";
		default:
			return "Unknown Error";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x51f9
movq -0x18(%rbp), %rax
leaq 0x5561(%rip), %rcx      # 0xa710
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6689(%rip), %rax      # 0xb848
movq %rax, -0x8(%rbp)
jmp 0x5204
leaq 0x667f(%rip), %rax      # 0xb84b
movq %rax, -0x8(%rbp)
jmp 0x5204
leaq 0x667f(%rip), %rax      # 0xb858
movq %rax, -0x8(%rbp)
jmp 0x5204
leaq 0x667f(%rip), %rax      # 0xb865
movq %rax, -0x8(%rbp)
jmp 0x5204
leaq 0x6688(%rip), %rax      # 0xb87b
movq %rax, -0x8(%rbp)
jmp 0x5204
leaq 0x6690(%rip), %rax      # 0xb890
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/main.c
// Function: flash_addr_to_page_floor
static int flash_addr_to_page_floor(uint32_t addr)
{
	int page;
	uint32_t *psize;

	if (!is_addr_in_flash(addr))
		return 0;

	page = 0;
	addr -= stm->dev->fl_start;
	psize = stm->dev->fl_ps;

	while (addr >= psize[0]) {
		addr -= psize[0];
		page++;
		if (psize[1])
			psize++;
	}

	return page;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x5210
cmpl $0x0, %eax
jne 0x5331
movl $0x0, -0x4(%rbp)
jmp 0x53a1
movl $0x0, -0xc(%rbp)
movq 0xb061(%rip), %rax      # 0x103a0
movq 0x20(%rax), %rax
movl 0x18(%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0xb04b(%rip), %rax      # 0x103a0
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x539b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x5399
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x5361
movl -0xc(%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/main.c
// Function: flash_page_to_addr
static uint32_t flash_page_to_addr(int page)
{
	int i;
	uint32_t addr, *psize;

	addr = stm->dev->fl_start;
	psize = stm->dev->fl_ps;

	for (i = 0; i < page; i++) {
		addr += psize[0];
		if (psize[1])
			psize++;
	}

	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0xafe2(%rip), %rax      # 0x103a0
movq 0x20(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0xc(%rbp)
movq 0xafd1(%rip), %rax      # 0x103a0
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5419
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x540c
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x540e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x53e2
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/main.c
// Function: action2str
static const char *action2str(enum actions act)
{
	switch (act) {
		case ACT_READ:
			return "memory read";
		case ACT_WRITE:
			return "memory write";
		case ACT_WRITE_UNPROTECT:
			return "write unprotect";
		case ACT_READ_PROTECT:
			return "read protect";
		case ACT_READ_UNPROTECT:
			return "read unprotect";
		case ACT_ERASE_ONLY:
			return "flash erase";
		case ACT_CRC:
			return "memory crc";
		default:
			return "";
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x5566
movq -0x18(%rbp), %rax
leaq 0x5222(%rip), %rcx      # 0xa724
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x63d5(%rip), %rax      # 0xb8e7
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x63d4(%rip), %rax      # 0xb8f3
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x63d4(%rip), %rax      # 0xb900
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x63d7(%rip), %rax      # 0xb910
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x63d7(%rip), %rax      # 0xb91d
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x63d9(%rip), %rax      # 0xb92c
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x63d8(%rip), %rax      # 0xb938
movq %rax, -0x8(%rbp)
jmp 0x5571
leaq 0x521f(%rip), %rax      # 0xa78c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/port.c
// Function: port_open
port_err_t port_open(struct port_options *ops, struct port_interface **outport)
{
	int ret;
	static struct port_interface **port;

	for (port = ports; *port; port++) {
		ret = (*port)->open(*port, ops);
		if (ret == PORT_ERR_NODEV)
			continue;
		if (ret == PORT_ERR_OK)
			break;
		fprintf(stderr, "Error probing interface \"%s\"\n",
			(*port)->name);
	}
	if (*port == NULL) {
		fprintf(stderr, "Cannot handle device \"%s\"\n",
			ops->device);
		return PORT_ERR_UNKNOWN;
	}

	*outport = *port;
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xad19(%rip), %rax      # 0x102b0
movq %rax, 0xae62(%rip)      # 0x10400
movq 0xae5b(%rip), %rax      # 0x10400
cmpq $0x0, (%rax)
je 0x5615
movq 0xae4e(%rip), %rax      # 0x10400
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0xae40(%rip), %rcx      # 0x10400
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x55d4
jmp 0x5601
cmpl $0x0, -0x1c(%rbp)
jne 0x55dc
jmp 0x5615
movq 0xaa0d(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq 0xae13(%rip), %rax      # 0x10400
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x6349(%rip), %rsi      # 0xb943
movb $0x0, %al
callq 0x2160
movq 0xadf8(%rip), %rax      # 0x10400
addq $0x8, %rax
movq %rax, 0xaded(%rip)      # 0x10400
jmp 0x559e
movq 0xade4(%rip), %rax      # 0x10400
cmpq $0x0, (%rax)
jne 0x564a
movq 0xa9c7(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x6327(%rip), %rsi      # 0xb961
movb $0x0, %al
callq 0x2160
movl $0x3, -0x4(%rbp)
jmp 0x5662
movq 0xadaf(%rip), %rax      # 0x10400
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_baud_int
unsigned int serial_get_baud_int(const serial_baud_t baud) {
	switch(baud) {
		case SERIAL_BAUD_1200  : return 1200  ;
		case SERIAL_BAUD_1800  : return 1800  ;
		case SERIAL_BAUD_2400  : return 2400  ;
		case SERIAL_BAUD_4800  : return 4800  ;
		case SERIAL_BAUD_9600  : return 9600  ;
		case SERIAL_BAUD_19200 : return 19200 ;
		case SERIAL_BAUD_38400 : return 38400 ;
		case SERIAL_BAUD_57600 : return 57600 ;
		case SERIAL_BAUD_115200: return 115200;
		case SERIAL_BAUD_128000: return 128000;
		case SERIAL_BAUD_230400: return 230400;
		case SERIAL_BAUD_256000: return 256000;
		case SERIAL_BAUD_460800: return 460800;
		case SERIAL_BAUD_500000: return 500000;
		case SERIAL_BAUD_576000: return 576000;
		case SERIAL_BAUD_921600: return 921600;
		case SERIAL_BAUD_1000000: return 1000000;
		case SERIAL_BAUD_1500000: return 1500000;
		case SERIAL_BAUD_2000000: return 2000000;

		case SERIAL_BAUD_INVALID:
		default:
			return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x13, %rax
ja 0x5968
movq -0x10(%rbp), %rax
leaq 0x60d9(%rip), %rcx      # 0xb97c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4b0, -0x4(%rbp)      # imm = 0x4B0
jmp 0x596f
movl $0x708, -0x4(%rbp)      # imm = 0x708
jmp 0x596f
movl $0x960, -0x4(%rbp)      # imm = 0x960
jmp 0x596f
movl $0x12c0, -0x4(%rbp)     # imm = 0x12C0
jmp 0x596f
movl $0x2580, -0x4(%rbp)     # imm = 0x2580
jmp 0x596f
movl $0x4b00, -0x4(%rbp)     # imm = 0x4B00
jmp 0x596f
movl $0x9600, -0x4(%rbp)     # imm = 0x9600
jmp 0x596f
movl $0xe100, -0x4(%rbp)     # imm = 0xE100
jmp 0x596f
movl $0x1c200, -0x4(%rbp)    # imm = 0x1C200
jmp 0x596f
movl $0x1f400, -0x4(%rbp)    # imm = 0x1F400
jmp 0x596f
movl $0x38400, -0x4(%rbp)    # imm = 0x38400
jmp 0x596f
movl $0x3e800, -0x4(%rbp)    # imm = 0x3E800
jmp 0x596f
movl $0x70800, -0x4(%rbp)    # imm = 0x70800
jmp 0x596f
movl $0x7a120, -0x4(%rbp)    # imm = 0x7A120
jmp 0x596f
movl $0x8ca00, -0x4(%rbp)    # imm = 0x8CA00
jmp 0x596f
movl $0xe1000, -0x4(%rbp)    # imm = 0xE1000
jmp 0x596f
movl $0xf4240, -0x4(%rbp)    # imm = 0xF4240
jmp 0x596f
movl $0x16e360, -0x4(%rbp)   # imm = 0x16E360
jmp 0x596f
movl $0x1e8480, -0x4(%rbp)   # imm = 0x1E8480
jmp 0x596f
jmp 0x5968
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_bits
serial_bits_t serial_get_bits(const char *mode) {
	if (!mode)
		return SERIAL_BITS_INVALID;
	switch(mode[0]) {
		case '5': return SERIAL_BITS_5;
		case '6': return SERIAL_BITS_6;
		case '7': return SERIAL_BITS_7;
		case '8': return SERIAL_BITS_8;

		default:
			return SERIAL_BITS_INVALID;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5998
movl $0x4, -0x4(%rbp)
jmp 0x59ec
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
addl $-0x35, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x59e5
movq -0x18(%rbp), %rax
leaq 0x6014(%rip), %rcx      # 0xb9cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x59ec
movl $0x1, -0x4(%rbp)
jmp 0x59ec
movl $0x2, -0x4(%rbp)
jmp 0x59ec
movl $0x3, -0x4(%rbp)
jmp 0x59ec
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_bits_int
unsigned int serial_get_bits_int(const serial_bits_t bits) {
	switch(bits) {
		case SERIAL_BITS_5: return 5;
		case SERIAL_BITS_6: return 6;
		case SERIAL_BITS_7: return 7;
		case SERIAL_BITS_8: return 8;

		default:
			return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x5a4c
movq -0x10(%rbp), %rax
leaq 0x5fbd(%rip), %rcx      # 0xb9dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, -0x4(%rbp)
jmp 0x5a53
movl $0x6, -0x4(%rbp)
jmp 0x5a53
movl $0x7, -0x4(%rbp)
jmp 0x5a53
movl $0x8, -0x4(%rbp)
jmp 0x5a53
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_parity
serial_parity_t serial_get_parity(const char *mode) {
	if (!mode || !mode[0])
		return SERIAL_PARITY_INVALID;
	switch(mode[1]) {
		case 'N':
		case 'n':
			return SERIAL_PARITY_NONE;
		case 'E':
		case 'e':
			return SERIAL_PARITY_EVEN;
		case 'O':
		case 'o':
			return SERIAL_PARITY_ODD;

		default:
			return SERIAL_PARITY_INVALID;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5a78
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x5a81
movl $0x3, -0x4(%rbp)
jmp 0x5ae7
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x45, %eax
je 0x5ace
jmp 0x5a93
movl -0x14(%rbp), %eax
subl $0x4e, %eax
je 0x5ac5
jmp 0x5a9d
movl -0x14(%rbp), %eax
subl $0x4f, %eax
je 0x5ad7
jmp 0x5aa7
movl -0x14(%rbp), %eax
subl $0x65, %eax
je 0x5ace
jmp 0x5ab1
movl -0x14(%rbp), %eax
subl $0x6e, %eax
je 0x5ac5
jmp 0x5abb
movl -0x14(%rbp), %eax
subl $0x6f, %eax
je 0x5ad7
jmp 0x5ae0
movl $0x0, -0x4(%rbp)
jmp 0x5ae7
movl $0x1, -0x4(%rbp)
jmp 0x5ae7
movl $0x2, -0x4(%rbp)
jmp 0x5ae7
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_parity_str
char serial_get_parity_str(const serial_parity_t parity) {
	switch(parity) {
		case SERIAL_PARITY_NONE: return 'N';
		case SERIAL_PARITY_EVEN: return 'E';
		case SERIAL_PARITY_ODD : return 'O';

		default:
			return ' ';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x5b17
jmp 0x5b03
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x5b1d
jmp 0x5b0d
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x5b23
jmp 0x5b29
movb $0x4e, -0x1(%rbp)
jmp 0x5b2d
movb $0x45, -0x1(%rbp)
jmp 0x5b2d
movb $0x4f, -0x1(%rbp)
jmp 0x5b2d
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_stopbit
serial_stopbit_t serial_get_stopbit(const char *mode) {
	if (!mode || !mode[0] || !mode[1])
		return SERIAL_STOPBIT_INVALID;
	switch(mode[2]) {
		case '1': return SERIAL_STOPBIT_1;
		case '2': return SERIAL_STOPBIT_2;

		default:
			return SERIAL_STOPBIT_INVALID;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5b62
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5b62
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x5b6b
movl $0x2, -0x4(%rbp)
jmp 0x5ba0
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x31, %eax
je 0x5b87
jmp 0x5b7d
movl -0x14(%rbp), %eax
subl $0x32, %eax
je 0x5b90
jmp 0x5b99
movl $0x0, -0x4(%rbp)
jmp 0x5ba0
movl $0x1, -0x4(%rbp)
jmp 0x5ba0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/serial_common.c
// Function: serial_get_stopbit_int
unsigned int serial_get_stopbit_int(const serial_stopbit_t stopbit) {
	switch(stopbit) {
		case SERIAL_STOPBIT_1: return 1;
		case SERIAL_STOPBIT_2: return 2;

		default:
			return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x5bcd
jmp 0x5bc3
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x5bd6
jmp 0x5bdf
movl $0x1, -0x4(%rbp)
jmp 0x5be6
movl $0x2, -0x4(%rbp)
jmp 0x5be6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/./serial_posix.c
// Function: serial_posix_open
static port_err_t serial_posix_open(struct port_interface *port,
				    struct port_options *ops)
{
	serial_t *h;

	/* 1. check options */
	if (ops->baudRate == SERIAL_BAUD_INVALID)
		return PORT_ERR_UNKNOWN;
	if (serial_get_bits(ops->serial_mode) == SERIAL_BITS_INVALID)
		return PORT_ERR_UNKNOWN;
	if (serial_get_parity(ops->serial_mode) == SERIAL_PARITY_INVALID)
		return PORT_ERR_UNKNOWN;
	if (serial_get_stopbit(ops->serial_mode) == SERIAL_STOPBIT_INVALID)
		return PORT_ERR_UNKNOWN;

	/* 2. open it */
	h = serial_open(ops->device);
	if (h == NULL)
		return PORT_ERR_UNKNOWN;

	/* 3. check for tty (but only warn) */
	if (!isatty(h->fd))
		fprintf(stderr, "Warning: Not a tty: %s\n", ops->device);

	/* 4. set options */
	if (serial_setup(h, ops->baudRate,
			 serial_get_bits(ops->serial_mode),
			 serial_get_parity(ops->serial_mode),
			 serial_get_stopbit(ops->serial_mode)
			) != PORT_ERR_OK) {
		serial_close(h);
		return PORT_ERR_UNKNOWN;
	}

	port->private = h;
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x5c16
movl $0x3, -0x4(%rbp)
jmp 0x5d40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5980
cmpl $0x4, %eax
jne 0x5c34
movl $0x3, -0x4(%rbp)
jmp 0x5d40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5a60
cmpl $0x3, %eax
jne 0x5c52
movl $0x3, -0x4(%rbp)
jmp 0x5d40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5b40
cmpl $0x2, %eax
jne 0x5c70
movl $0x3, -0x4(%rbp)
jmp 0x5d40
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x60b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5c93
movl $0x3, -0x4(%rbp)
jmp 0x5d40
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x2060
cmpl $0x0, %eax
jne 0x5cc2
movq 0xa346(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x5d9e(%rip), %rsi      # 0xba59
movb $0x0, %al
callq 0x2160
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5980
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5a60
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5b40
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movl %eax, %r8d
callq 0x61a0
cmpl $0x0, %eax
je 0x5d2d
movq -0x20(%rbp), %rdi
callq 0x6530
movl $0x3, -0x4(%rbp)
jmp 0x5d40
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/./serial_posix.c
// Function: serial_posix_close
static port_err_t serial_posix_close(struct port_interface *port)
{
	serial_t *h;

	h = (serial_t *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;

	serial_close(h);
	port->private = NULL;
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d78
movl $0x3, -0x4(%rbp)
jmp 0x5d94
movq -0x18(%rbp), %rdi
callq 0x6530
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/./serial_posix.c
// Function: serial_posix_flush
static port_err_t serial_posix_flush(struct port_interface *port)
{
	serial_t *h;
	h = (serial_t *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;

	serial_flush(h);

	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5dc8
movl $0x3, -0x4(%rbp)
jmp 0x5dd8
movq -0x18(%rbp), %rdi
callq 0x6590
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/./serial_posix.c
// Function: serial_posix_read
static port_err_t serial_posix_read(struct port_interface *port, void *buf,
				     size_t nbyte)
{
	serial_t *h;
	ssize_t r;
	uint8_t *pos = (uint8_t *)buf;

	h = (serial_t *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;

	while (nbyte) {
		r = read(h->fd, pos, nbyte);
		if (r == 0)
			return PORT_ERR_TIMEDOUT;
		if (r < 0)
			return PORT_ERR_UNKNOWN;

		nbyte -= r;
		pos += r;
	}
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5e28
movl $0x3, -0x4(%rbp)
jmp 0x5e8c
jmp 0x5e2a
cmpq $0x0, -0x20(%rbp)
je 0x5e85
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5e58
movl $0x2, -0x4(%rbp)
jmp 0x5e8c
cmpq $0x0, -0x30(%rbp)
jge 0x5e68
movl $0x3, -0x4(%rbp)
jmp 0x5e8c
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5e2a
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/./serial_posix.c
// Function: serial_posix_write
static port_err_t serial_posix_write(struct port_interface *port, void *buf,
				      size_t nbyte)
{
	serial_t *h;
	ssize_t r;
	const uint8_t *pos = (const uint8_t *)buf;

	h = (serial_t *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;

	while (nbyte) {
		r = write(h->fd, pos, nbyte);
		if (r < 1)
			return PORT_ERR_UNKNOWN;

		nbyte -= r;
		pos += r;
	}
	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5ed8
movl $0x3, -0x4(%rbp)
jmp 0x5f2c
jmp 0x5eda
cmpq $0x0, -0x20(%rbp)
je 0x5f25
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2090
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x30(%rbp)
jge 0x5f08
movl $0x3, -0x4(%rbp)
jmp 0x5f2c
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5eda
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/./serial_posix.c
// Function: serial_posix_gpio
static port_err_t serial_posix_gpio(struct port_interface *port,
				    serial_gpio_t n, int level)
{
	serial_t *h;
	int bit, lines;

	h = (serial_t *)port->private;
	if (h == NULL)
		return PORT_ERR_UNKNOWN;

	switch (n) {
	case GPIO_RTS:
		bit = TIOCM_RTS;
		break;

	case GPIO_DTR:
		bit = TIOCM_DTR;
		break;

	case GPIO_BRK:
		if (level == 0)
			return PORT_ERR_OK;
		if (tcsendbreak(h->fd, 1))
			return PORT_ERR_UNKNOWN;
		return PORT_ERR_OK;

	default:
		return PORT_ERR_UNKNOWN;
	}

	/* handle RTS/DTR */
	if (ioctl(h->fd, TIOCMGET, &lines))
		return PORT_ERR_UNKNOWN;
	lines = level ? lines | bit : lines & ~bit;
	if (ioctl(h->fd, TIOCMSET, &lines))
		return PORT_ERR_UNKNOWN;

	return PORT_ERR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5f71
movl $0x3, -0x4(%rbp)
jmp 0x605d
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x5f92
jmp 0x5f7e
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x5f9b
jmp 0x5f88
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x5fa4
jmp 0x5fe0
movl $0x4, -0x24(%rbp)
jmp 0x5fe9
movl $0x2, -0x24(%rbp)
jmp 0x5fe9
cmpl $0x0, -0x18(%rbp)
jne 0x5fb6
movl $0x0, -0x4(%rbp)
jmp 0x605d
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
callq 0x2150
cmpl $0x0, %eax
je 0x5fd7
movl $0x3, -0x4(%rbp)
jmp 0x605d
movl $0x0, -0x4(%rbp)
jmp 0x605d
movl $0x3, -0x4(%rbp)
jmp 0x605d
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x5415, %esi           # imm = 0x5415
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x2110
cmpl $0x0, %eax
je 0x600d
movl $0x3, -0x4(%rbp)
jmp 0x605d
cmpl $0x0, -0x18(%rbp)
je 0x601e
movl -0x28(%rbp), %eax
orl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x602c
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x5418, %esi           # imm = 0x5418
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x2110
cmpl $0x0, %eax
je 0x6056
movl $0x3, -0x4(%rbp)
jmp 0x605d
movl $0x0, -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/./serial_posix.c
// Function: serial_open
static serial_t *serial_open(const char *device)
{
	serial_t *h = calloc(sizeof(serial_t), 1);

	h->fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
	if (h->fd < 0) {
		free(h);
		return NULL;
	}

	if(lockf(h->fd,F_TLOCK,0) != 0)
	{
		fprintf(stderr, "Error: %s is already open\n", device);
		free(h);
		return NULL;
	}
	fcntl(h->fd, F_SETFL, 0);

	tcgetattr(h->fd, &h->oldtio);
	tcgetattr(h->fd, &h->newtio);

	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x88, %edi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x902, %esi            # imm = 0x902
movb $0x0, %al
callq 0x2220
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x6106
movq -0x18(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
jmp 0x6190
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x20f0
cmpl $0x0, %eax
je 0x614e
movq 0x9eca(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x593d(%rip), %rsi      # 0xba71
movb $0x0, %al
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
jmp 0x6190
movq -0x18(%rbp), %rax
movl (%rax), %edi
movl $0x4, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2080
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x2200
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x2200
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/koendv[P]stm32duino-raspberrypi/Arduino_Tools/src/stm32flash/./serial_posix.c
// Function: serial_close
static void serial_close(serial_t *h)
{
	serial_flush(h);
	tcsetattr(h->fd, TCSANOW, &h->oldtio);
	lockf(h->fd, F_ULOCK, 0);
	close(h->fd);
	free(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6590
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x2210
movq -0x8(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x20f0
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %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_get_ack_timeout
static stm32_err_t stm32_get_ack_timeout(const stm32_t *stm, time_t timeout)
{
	struct port_interface *port = stm->port;
	uint8_t byte;
	port_err_t p_err;
	time_t t0, t1;

	if (!(port->flags & PORT_RETRY))
		timeout = 0;

	if (timeout)
		time(&t0);

	do {
		p_err = port->read(port, &byte, 1);
		if (p_err == PORT_ERR_TIMEDOUT && timeout) {
			time(&t1);
			if (t1 < t0 + timeout)
				continue;
		}

		if (p_err != PORT_ERR_OK) {
			fprintf(stderr, "Failed to read ACK byte\n");
			return STM32_ERR_UNKNOWN;
		}

		if (byte == STM32_ACK)
			return STM32_ERR_OK;
		if (byte == STM32_NACK)
			return STM32_ERR_NACK;
		if (byte != STM32_BUSY) {
			fprintf(stderr, "Got byte 0x%02x instead of ACK\n",
				byte);
			return STM32_ERR_UNKNOWN;
		}
	} while (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x7903
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7913
leaq -0x30(%rbp), %rdi
callq 0x21a0
jmp 0x7915
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rdi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jne 0x795a
cmpq $0x0, -0x18(%rbp)
je 0x795a
leaq -0x38(%rbp), %rdi
callq 0x21a0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jge 0x7958
jmp 0x79d5
jmp 0x795a
cmpl $0x0, -0x28(%rbp)
je 0x7981
movq 0x8689(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x49b4(%rip), %rsi      # 0xc325
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x79e1
movzbl -0x21(%rbp), %eax
cmpl $0x79, %eax
jne 0x7993
movl $0x0, -0x4(%rbp)
jmp 0x79e1
movzbl -0x21(%rbp), %eax
cmpl $0x1f, %eax
jne 0x79a5
movl $0x2, -0x4(%rbp)
jmp 0x79e1
movzbl -0x21(%rbp), %eax
cmpl $0x76, %eax
je 0x79d3
movq 0x863b(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movzbl -0x21(%rbp), %edx
leaq 0x497b(%rip), %rsi      # 0xc33e
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x79e1
jmp 0x79d5
movb $0x1, %al
testb $0x1, %al
jne 0x7915
jmp 0x79e1
movl -0x4(%rbp), %eax
addq $0x40, %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_warn_stretching
static void stm32_warn_stretching(const char *f)
{
	fprintf(stderr, "Attention !!!\n");
	fprintf(stderr, "\tThis %s error could be caused by your I2C\n", f);
	fprintf(stderr, "\tcontroller not accepting \"clock stretching\"\n");
	fprintf(stderr, "\tas required by bootloader.\n");
	fprintf(stderr, "\tCheck \"I2C.txt\" in stm32flash source code.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x85ed(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4951(%rip), %rsi      # 0xc35e
movb $0x0, %al
callq 0x2160
movq 0x85d5(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x4944(%rip), %rsi      # 0xc36d
movb $0x0, %al
callq 0x2160
movq 0x85b9(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4958(%rip), %rsi      # 0xc399
movb $0x0, %al
callq 0x2160
movq 0x85a1(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x496e(%rip), %rsi      # 0xc3c7
movb $0x0, %al
callq 0x2160
movq 0x8589(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x4973(%rip), %rsi      # 0xc3e4
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nop