LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: parse_arguments
int
parse_arguments(int argc,
                char **argv,
                int *print_usage,
                int *run_forever)
{
    for(int i = 1; i < argc; i++)
    {
        if(strncmp(argv[i], "-h", 2) == 0)
        {
            *print_usage = 1;
        }
        else if(strncmp(argv[i], "-i", 2) == 0)
        {
            *run_forever = 1;
        }
        else
        {
            printf("Invalid option: '%s'\n", argv[i]);
            print_help(argv[0]);
            return(-1);
        }
    }
    
    return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1b3c7
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x262eb(%rip), %rsi     # 0x41628
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1b358
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1b3b7
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x262c0(%rip), %rsi     # 0x4162b
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1b386
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1b3b5
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x26295(%rip), %rdi     # 0x4162e
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1b2b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b3ce
jmp 0x1b3b7
jmp 0x1b3b9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b31e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: main
int
main(int argc, char **argv)
{
    int print_usage = 0;
    int run_forever = 0;
    
    int error = parse_arguments(argc, argv, &print_usage, &run_forever);
    if(error)
    {
        return(error);
    }
    if(print_usage)
    {
        print_help(argv[0]);
        return(0);
    }
    
    int results = 0;
    if(run_forever)
    {
        while(1)
        {
            run_tests();
        }
    }
    else
    {
        results = run_tests();
    }

    return(results);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1b300
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1b429
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b468
cmpl $0x0, -0x14(%rbp)
je 0x1b444
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1b2b0
movl $0x0, -0x4(%rbp)
jmp 0x1b468
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x1b45a
jmp 0x1b453
callq 0x1a940
jmp 0x1b453
callq 0x1a940
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yugecin[P]evilwm/client.c
// Function: client_raise
void client_raise(Client *c) {
	XRaiseWindow(dpy, c->parent);
	clients_stacking_order = list_to_tail(clients_stacking_order, c);
#ifdef ABOVE
	do_above();
#endif
	ewmh_set_net_client_list_stacking(c->screen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc08d(%rip), %rax      # 0xfa90
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x36e0
leaq 0xbfee(%rip), %rax      # 0xfa08
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x6f70
movq %rax, %rcx
leaq 0xbfd8(%rip), %rax      # 0xfa08
movq %rcx, (%rax)
callq 0x3a50
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6870
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yugecin[P]evilwm/client.c
// Function: do_above
void do_above(void) {
	if (doabove) {
		// this may get heavy
		struct list *iter;
		for (iter = clients_stacking_order; iter; iter = iter->next) {
			Client *cur = iter->data;
			if (cur->isabove) {
				XRaiseWindow(dpy, cur->parent);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb98d(%rip), %rax      # 0xf3ec
cmpl $0x0, (%rax)
je 0x3aba
leaq 0xbf9d(%rip), %rax      # 0xfa08
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ab8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x84(%rax)
je 0x3aa9
leaq 0xbff7(%rip), %rax      # 0xfa90
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x36e0
jmp 0x3aab
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a72
jmp 0x3aba
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yugecin[P]evilwm/events.c
// Function: handle_button_event
static void handle_button_event(XButtonEvent *e) {
	Client *c = find_client(e->window);

	if (c) {
		switch (e->button) {
			case Button1:
				drag(c); break;
			case Button2:
				sweep(e->x, e->y, c); break;
			case Button3:
				client_lower(c); break;
			default: break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ecc
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x4e99
jmp 0x4e85
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x4ea4
jmp 0x4e8f
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x4ebd
jmp 0x4ec8
movq -0x10(%rbp), %rdi
callq 0x9c40
jmp 0x4eca
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x44(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x9300
jmp 0x4eca
movq -0x10(%rbp), %rdi
callq 0x3ac0
jmp 0x4eca
jmp 0x4eca
jmp 0x4ecc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yugecin[P]evilwm/ewmh.c
// Function: ewmh_set_net_wm_state
void ewmh_set_net_wm_state(Client *c) {
	Atom state[3];
	int i = 0;
	if (c->oldh)
		state[i++] = xa_net_wm_state_maximized_vert;
	if (c->oldw)
		state[i++] = xa_net_wm_state_maximized_horz;
#ifndef NOMAXIMISE
	if (c->oldh && c->oldw)
		state[i++] = xa_net_wm_state_fullscreen;
#endif
	XChangeProperty(dpy, c->window, xa_net_wm_state,
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&state, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0x6c26
movq 0x8d54(%rip), %rcx      # 0xf968
movl -0x24(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
cltq
movq %rcx, -0x20(%rbp,%rax,8)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x6c49
movq 0x8d39(%rip), %rcx      # 0xf970
movl -0x24(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
cltq
movq %rcx, -0x20(%rbp,%rax,8)
leaq 0x8e40(%rip), %rax      # 0xfa90
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0x8cff(%rip), %rdx      # 0xf960
movl -0x24(%rbp), %eax
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
leaq -0x20(%rbp), %r10
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3480
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yugecin[P]evilwm/main.c
// Function: set_gaps
static void set_gaps(const char *arg) {
	unsigned int gapidx;

	opt_numgaps = 0;
	gapidx = 0;
	while (*arg) {
		opt_gaps[gapidx] = atoi(arg);
		++gapidx;
		if (gapidx >= sizeof(opt_gaps)/sizeof(opt_gaps[0])) {
			printf("toobig\n");
			return;
		}
		if ((gapidx % 4) == 0) {
			opt_numgaps++;
		}
		while (*arg) {
			if (*(arg++) == ',') {
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0x7d6a(%rip)      # 0xfa20
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7d4b
movq -0x8(%rbp), %rdi
callq 0x3640
movl %eax, %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x7d4f(%rip), %rax      # 0xfa30
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x10, %rax
jb 0x7d06
leaq 0x4882(%rip), %rdi      # 0xc57f
movb $0x0, %al
callq 0x3210
jmp 0x7d4b
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x7d20
movl 0x7d09(%rip), %eax      # 0xfa20
addl $0x1, %eax
movl %eax, 0x7d00(%rip)      # 0xfa20
jmp 0x7d22
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7d46
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x7d44
jmp 0x7d46
jmp 0x7d22
jmp 0x7cbd
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yugecin[P]evilwm/screen.c
// Function: apply_gaps
static void apply_gaps(Client *c) {
	// do gaps, dirty
	int overlap;
	int *gaps;

	gaps = opt_gaps + c->gapindex * 4;
	if (c->y < *(gaps+0)) {
		c->y = *(gaps+0);
	}
	if (c->x < *(gaps+3)) {
		c->x = *(gaps+3);
	}
	overlap = c->y + c->height - (DisplayHeight(dpy, c->screen->screen) - *(gaps+2));
	while (overlap-- > 0) {
		if (c->y > *(gaps+0)) {
			c->y--;
		} else {
			c->height--;
		}
	}
	overlap = c->x + c->width - (DisplayWidth(dpy, c->screen->screen) - *(gaps+1));
	while (overlap-- > 0) {
		if (c->x > *(gaps+3)) {
			c->x--;
		} else {
			c->width--;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
shll $0x2, %eax
movslq %eax, %rcx
leaq 0x52b4(%rip), %rax      # 0xfa30
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa7a3
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xa7c1
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x30(%rcx), %eax
leaq 0x52ba(%rip), %rcx      # 0xfa90
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
movl 0x1c(%rcx), %ecx
movq -0x18(%rbp), %rdx
subl 0x8(%rdx), %ecx
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0xa83e
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xa82f
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xa83c
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0xa801
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x2c(%rcx), %eax
leaq 0x523d(%rip), %rcx      # 0xfa90
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
movl 0x18(%rcx), %ecx
movq -0x18(%rbp), %rdx
subl 0x4(%rdx), %ecx
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0xa8bc
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0xa8ad
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0xa8ba
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0xa87e
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/rf.c
// Function: main
void main()
{
  FIL f;
  int w;
  FATFS fs;
  char buf[1024];
  FCHK(f_mount(&fs, "", 1)); 
  if (f_open(&f, "/abc/a.txt", FA_OPEN_EXISTING|FA_READ) == FR_OK) {
    FCHK(f_read(&f, buf, 9, &w));
    printf("open & write %d %s\n", w, buf);
    FCHK(f_close(&f));
  } else {
    printf("open error\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
leaq -0x4b0(%rbp), %rdi
leaq 0x630c(%rip), %rsi      # 0x74a5
movl $0x1, %edx
callq 0x1640
movl %eax, -0x8b4(%rbp)
movl -0x8b4(%rbp), %eax
movl %eax, -0x8c0(%rbp)
movl -0x8b4(%rbp), %edi
callq 0x12e0
movl -0x8c0(%rbp), %edx
movq %rax, %rcx
leaq 0x5e84(%rip), %rdi      # 0x7054
leaq 0x5e90(%rip), %rsi      # 0x7067
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
leaq 0x5e8f(%rip), %rsi      # 0x707b
movl $0x1, %edx
callq 0x2010
cmpl $0x0, %eax
jne 0x12bd
leaq -0x8b0(%rbp), %rsi
leaq -0x250(%rbp), %rdi
movl $0x9, %edx
leaq -0x254(%rbp), %rcx
callq 0x2c90
movl %eax, -0x8b8(%rbp)
movl -0x8b8(%rbp), %eax
movl %eax, -0x8c8(%rbp)
movl -0x8b8(%rbp), %edi
callq 0x12e0
movl -0x8c8(%rbp), %edx
movq %rax, %rcx
leaq 0x5e09(%rip), %rdi      # 0x7054
leaq 0x5e34(%rip), %rsi      # 0x7086
movb $0x0, %al
callq 0x1040
movl -0x254(%rbp), %esi
leaq -0x8b0(%rbp), %rdx
leaq 0x5e30(%rip), %rdi      # 0x709d
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
callq 0x3b50
movl %eax, -0x8bc(%rbp)
movl -0x8bc(%rbp), %eax
movl %eax, -0x8c4(%rbp)
movl -0x8bc(%rbp), %edi
callq 0x12e0
movl -0x8c4(%rbp), %edx
movq %rax, %rcx
leaq 0x5da7(%rip), %rdi      # 0x7054
leaq 0x5dfd(%rip), %rsi      # 0x70b1
movb $0x0, %al
callq 0x1040
jmp 0x12cb
leaq 0x5df9(%rip), %rdi      # 0x70bd
movb $0x0, %al
callq 0x1040
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_01/simple.c
// Function: main
int main(void)
{
	int n;
	char buf[BUFFSIZE];

	while ((n = read(STDIN_FILENO, buf, BUFFSIZE)) > 0)
		if (write(STDOUT_FILENO, buf, n) != n)
			err("write error\n");
	if (n < 0)
		err("read error\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
movl $0x0, -0x4(%rbp)
leaq -0x1010(%rbp), %rsi
xorl %edi, %edi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x11ae
leaq -0x1010(%rbp), %rsi
movslq -0x8(%rbp), %rdx
movl $0x1, %edi
callq 0x1030
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
je 0x11ac
leaq 0xe62(%rip), %rdi       # 0x2004
movl $0xd, %esi
callq 0x11d0
jmp 0x1162
cmpl $0x0, -0x8(%rbp)
jge 0x11c5
leaq 0xe56(%rip), %rdi       # 0x2011
movl $0xc, %esi
callq 0x11d0
xorl %eax, %eax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/subtptd.c
// Function: prv_set_prog_size
static void prv_set_prog_size(uint8_t *code, size_t bytes_written,
			      subtilis_error_t *err)
{
	if (bytes_written < 8) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	((uint32_t *)code)[1] =
	    SUBTILIS_PTD_PROGRAM_START + (int32_t)bytes_written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x8, -0x10(%rbp)
jae 0x11727
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x97907(%rip), %rdx     # 0xa9022
movl $0x22, %ecx
callq 0x148f0
jmp 0x1173a
movq -0x10(%rbp), %rax
movl %eax, %ecx
addl $0xf000, %ecx           # imm = 0xF000
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_movr
void subtilis_vfp_gen_movr(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	src = subtilis_arm_ir_to_dreg(instr->operands[1].reg);

	subtilis_vfp_add_copy(arm_s, SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_VFP_INSTR_FCPYD, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x4b, %edx
callq 0x86ea0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_movir
void subtilis_vfp_gen_movir(subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	double src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	src = instr->operands[1].real;

	subtilis_vfp_add_copy_imm(arm_s, SUBTILIS_ARM_CCODE_AL, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rdx
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rcx
movl $0xe, %esi
callq 0x86f10
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_movri32
void subtilis_vfp_gen_movri32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_reg_t tmp;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);
	src = subtilis_arm_ir_to_dreg(instr->operands[1].reg);
	tmp = subtilis_arm_ir_to_dreg(s->freg_counter++);

	subtilis_vfp_add_tran(arm_s, SUBTILIS_VFP_INSTR_FTOSIZD,
			      SUBTILIS_ARM_CCODE_AL, true, tmp, src, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_cptran(arm_s, SUBTILIS_VFP_INSTR_FMRS,
				SUBTILIS_ARM_CCODE_AL, true, dest, tmp, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6eea0
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x58, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x87350
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9dda9
jmp 0x9ddd1
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x5e, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x873e0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_movi32r
void subtilis_vfp_gen_movi32r(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_reg_t tmp;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	src = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);
	tmp = subtilis_arm_ir_to_dreg(s->freg_counter++);

	subtilis_vfp_add_cptran(arm_s, SUBTILIS_VFP_INSTR_FMSR,
				SUBTILIS_ARM_CCODE_AL, true, tmp, src, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_tran(arm_s, SUBTILIS_VFP_INSTR_FSITOD,
			      SUBTILIS_ARM_CCODE_AL, true, dest, tmp, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6eea0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x5d, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x873e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e099
jmp 0x9e0c1
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x51, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x87350
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: prv_gen_callr
static void prv_gen_callr(subtilis_ir_section_t *s, size_t start,
			  void *user_data, bool indirect, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_call_t *call = &s->ops[start]->op.call;

	subtilis_arm_gen_call_gen(s, start, user_data,
				  SUBTILIS_ARM_BR_LINK_REAL, indirect, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_dreg(call->reg);
	op1 = 0;

	subtilis_vfp_add_copy(arm_s, SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_VFP_INSTR_FCPYD, dest, op1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
movq -0x28(%rbp), %r9
movl $0x2, %ecx
andb $0x1, %al
movzbl %al, %r8d
callq 0x73900
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e17d
jmp 0x9e1b5
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
movl $0xe, %esi
movl $0x4b, %edx
callq 0x86ea0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: prv_data_simple
static void prv_data_simple(subtilis_ir_section_t *s,
			    subtilis_arm_instr_type_t itype, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t dest =
	    subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	subtilis_arm_reg_t op1 =
	    subtilis_arm_ir_to_dreg(instr->operands[1].reg);
	subtilis_arm_reg_t op2 =
	    subtilis_arm_ir_to_dreg(instr->operands[2].reg);
	subtilis_arm_section_t *arm_s = user_data;

	subtilis_vfp_add_data(arm_s, itype, SUBTILIS_ARM_CCODE_AL, dest, op1,
			      op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f840
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xe, %edx
movq %rax, (%rsp)
callq 0x87470
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: prv_data_imm
static void prv_data_imm(subtilis_ir_section_t *s,
			 subtilis_arm_instr_type_t itype, size_t start,
			 void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t op2 = subtilis_arm_ir_to_dreg(s->freg_counter++);
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t dest =
	    subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	subtilis_arm_reg_t op1 =
	    subtilis_arm_ir_to_dreg(instr->operands[1].reg);
	subtilis_arm_section_t *arm_s = user_data;

	subtilis_vfp_add_copy_imm(arm_s, SUBTILIS_ARM_CCODE_AL, op2,
				  instr->operands[2].real, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_data(arm_s, itype, SUBTILIS_ARM_CCODE_AL, dest, op1,
			      op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x28(%rbp), %rcx
movl $0xe, %esi
callq 0x86f10
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e3c3
jmp 0x9e3e8
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xe, %edx
movq %rax, (%rsp)
callq 0x87470
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_fma_right
void subtilis_vfp_gen_fma_right(subtilis_ir_section_t *s, size_t start,
				void *user_data, subtilis_error_t *err)
{
	subtilis_ir_inst_t *mul = &s->ops[start]->op.instr;
	subtilis_ir_inst_t *add = &s->ops[start + 1]->op.instr;
	subtilis_arm_reg_t dest = subtilis_arm_ir_to_dreg(add->operands[0].reg);
	subtilis_arm_reg_t op1 = subtilis_arm_ir_to_dreg(mul->operands[1].reg);
	subtilis_arm_reg_t op2 = subtilis_arm_ir_to_dreg(mul->operands[2].reg);
	subtilis_arm_reg_t op3 = subtilis_arm_ir_to_dreg(add->operands[1].reg);
	subtilis_arm_section_t *arm_s = user_data;

	subtilis_vfp_add_copy(arm_s, SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_VFP_INSTR_FCPYD, dest, op3, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_data(arm_s, SUBTILIS_VFP_INSTR_FMACD,
			      SUBTILIS_ARM_CCODE_AL, dest, op1, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f840
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x4b, %edx
callq 0x86ea0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e63f
jmp 0x9e666
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x60, %esi
movl $0xe, %edx
movq %rax, (%rsp)
callq 0x87470
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_nfma_right
void subtilis_vfp_gen_nfma_right(subtilis_ir_section_t *s, size_t start,
				 void *user_data, subtilis_error_t *err)
{
	subtilis_ir_inst_t *mul = &s->ops[start]->op.instr;
	subtilis_ir_inst_t *add = &s->ops[start + 1]->op.instr;
	subtilis_arm_reg_t dest = subtilis_arm_ir_to_dreg(add->operands[0].reg);
	subtilis_arm_reg_t op1 = subtilis_arm_ir_to_dreg(mul->operands[1].reg);
	subtilis_arm_reg_t op2 = subtilis_arm_ir_to_dreg(mul->operands[2].reg);
	subtilis_arm_reg_t op3 = subtilis_arm_ir_to_dreg(add->operands[1].reg);
	subtilis_arm_section_t *arm_s = user_data;

	subtilis_vfp_add_copy(arm_s, SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_VFP_INSTR_FCPYD, dest, op3, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_data(arm_s, SUBTILIS_VFP_INSTR_FNMACD,
			      SUBTILIS_ARM_CCODE_AL, dest, op1, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f840
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x4b, %edx
callq 0x86ea0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e81f
jmp 0x9e846
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x62, %esi
movl $0xe, %edx
movq %rax, (%rsp)
callq 0x87470
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_divr
void subtilis_vfp_gen_divr(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t dest =
	    subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	subtilis_arm_section_t *arm_s = user_data;

	prv_data_simple(s, SUBTILIS_VFP_INSTR_FDIVD, start, user_data, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_check_divbyzero(arm_s, s, dest, SUBTILIS_ERROR_CODE_DIV_BY_ZERO,
			    err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x70, %esi
callq 0x9e240
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9e93e
jmp 0x9e958
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x12, %ecx
callq 0x9e960
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_rdivir
void subtilis_vfp_gen_rdivir(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t dest =
	    subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	subtilis_arm_section_t *arm_s = user_data;

	prv_data_imm_reversed(s, SUBTILIS_VFP_INSTR_FDIVD, start, user_data,
			      err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_check_divbyzero(arm_s, s, dest, SUBTILIS_ERROR_CODE_DIV_BY_ZERO,
			    err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x70, %esi
callq 0x9e4b0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9ec0e
jmp 0x9ec28
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x12, %ecx
callq 0x9e960
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: prv_stran_instr
static void prv_stran_instr(subtilis_arm_instr_type_t itype,
			    subtilis_ir_section_t *s, size_t start,
			    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t base;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t offset = instr->operands[2].integer;

	dest = subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	base = subtilis_arm_ir_to_arm_reg(instr->operands[1].reg);

	subtilis_vfp_add_stran(arm_s, itype, SUBTILIS_ARM_CCODE_AL, dest, base,
			       offset, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6eea0
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x4c(%rbp), %r9d
movq -0x28(%rbp), %rax
movl $0xe, %edx
movq %rax, (%rsp)
callq 0x86ff0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_retr
void subtilis_vfp_gen_retr(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t op2;

	dest = 0;
	op2 = subtilis_arm_ir_to_dreg(instr->operands[0].reg);

	subtilis_vfp_add_copy(arm_s, SUBTILIS_ARM_CCODE_AL,
			      SUBTILIS_VFP_INSTR_FCPYD, dest, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x4b, %edx
callq 0x86ea0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9edcb
jmp 0x9ede0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x74350
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_sqr
void subtilis_vfp_gen_sqr(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	src = subtilis_arm_ir_to_dreg(instr->operands[1].reg);

	subtilis_vfp_add_sqrt(arm_s, SUBTILIS_VFP_INSTR_FSQRTD,
			      SUBTILIS_ARM_CCODE_AL, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0x79, %esi
movl $0xe, %edx
callq 0x875c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_absr
void subtilis_vfp_gen_absr(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_dreg(instr->operands[0].reg);
	src = subtilis_arm_ir_to_dreg(instr->operands[1].reg);

	subtilis_vfp_add_tran(arm_s, SUBTILIS_VFP_INSTR_FABSD,
			      SUBTILIS_ARM_CCODE_AL, true, dest, src, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x4f, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x87350
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_preamble
void subtilis_vfp_gen_preamble(subtilis_arm_section_t *arm_s,
			       subtilis_error_t *err)
{
	subtilis_arm_reg_t status;

	status = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, status, 0,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_sysreg(arm_s, SUBTILIS_VFP_INSTR_FMXR,
				SUBTILIS_ARM_CCODE_AL,
				SUBTILIS_VFP_SYSREG_FPSCR, status, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6eea0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r9
movq -0x10(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x70b20
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9fd24
jmp 0x9fd44
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r8
movq -0x10(%rbp), %r9
movl $0x7b, %esi
movl $0xe, %edx
movl $0x1, %ecx
callq 0x87630
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_movi8tofp
void subtilis_vfp_gen_movi8tofp(subtilis_ir_section_t *s, size_t start,
				void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_reg_t tmp;
	subtilis_arm_reg_t tmp1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *signx = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_dreg(signx->operands[0].reg);
	src = subtilis_arm_ir_to_arm_reg(signx->operands[1].reg);
	tmp = subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);
	tmp1 = subtilis_arm_ir_to_dreg(arm_s->freg_counter++);

	subtilis_arm_add_signx(arm_s, SUBTILIS_ARM_INSTR_SXTB,
			       SUBTILIS_ARM_CCODE_AL, tmp, src,
			       SUBTILIS_ARM_SIGNX_ROR_NONE, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_cptran(arm_s, SUBTILIS_VFP_INSTR_FMSR,
				SUBTILIS_ARM_CCODE_AL, true, tmp1, tmp, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_vfp_add_tran(arm_s, SUBTILIS_VFP_INSTR_FSITOD,
			      SUBTILIS_ARM_CCODE_AL, true, dest, tmp1, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6f840
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6eea0
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x6eea0
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
movq %rdi, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
callq 0x6f840
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0xa9, %esi
movl $0xe, %edx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x71eb0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9fe11
jmp 0x9fe6c
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x5d, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x873e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9fe44
jmp 0x9fe6c
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x51, %esi
movl $0xe, %edx
movl $0x1, %ecx
movq %rax, (%rsp)
callq 0x87350
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_gen_movfptoi32i32
void subtilis_vfp_gen_movfptoi32i32(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest1;
	subtilis_arm_reg_t dest2;
	subtilis_arm_reg_t src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *mov = &s->ops[start]->op.instr;

	dest1 = subtilis_arm_ir_to_arm_reg(mov->operands[0].reg);
	dest2 = subtilis_arm_ir_to_arm_reg(mov->operands[1].reg);
	src = subtilis_arm_ir_to_dreg(mov->operands[2].reg);

	subtilis_vfp_add_tran_dbl(arm_s, SUBTILIS_VFP_INSTR_FMRRD,
				  SUBTILIS_ARM_CCODE_AL, dest1, dest2, src, 0,
				  err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6eea0
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6eea0
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f840
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x7e, %esi
movl $0xe, %edx
xorl %r10d, %r10d
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x876a0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_preserve_regs
size_t subtilis_vfp_preserve_regs(subtilis_arm_section_t *arm_s,
				  int save_real_start, subtilis_error_t *err)
{
	int i;
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	size_t stf_site = INT_MAX;

	for (i = save_real_start; i < SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS; i++) {
		instr = subtilis_arm_section_add_instr(
		    arm_s, SUBTILIS_VFP_INSTR_FSTD, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return INT_MAX;

		stran = &instr->operands.vfp_stran;
		stran->ccode = SUBTILIS_ARM_CCODE_NV;
		stran->dest = i;
		stran->base = 13;
		stran->offset = 2;
		stran->pre_indexed = true;
		stran->write_back = true;
		stran->subtract = true;
		if (stf_site == INT_MAX)
			stf_site = arm_s->last_op;
	}

	return stf_site;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x7fffffff, -0x40(%rbp) # imm = 0x7FFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x10, -0x24(%rbp)
jge 0x9fff8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x48, %esi
callq 0x6fb60
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9ff84
movq $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jmp 0xa0000
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0xf, (%rax)
movslq -0x24(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq $0xd, 0x10(%rax)
movq -0x38(%rbp), %rax
movb $0x2, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x1a(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x1b(%rax)
cmpq $0x7fffffff, -0x40(%rbp) # imm = 0x7FFFFFFF
jne 0x9ffe8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x9ffea
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9ff51
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp_gen.c
// Function: subtilis_vfp_restore_regs
size_t subtilis_vfp_restore_regs(subtilis_arm_section_t *arm_s,
				 int save_real_start, subtilis_error_t *err)
{
	int i;
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	size_t ldf_site = INT_MAX;

	for (i = SUBTILIS_ARM_REG_MAX_VFP_DBL_REGS - 1; i >= save_real_start;
	     i--) {
		instr = subtilis_arm_section_add_instr(
		    arm_s, SUBTILIS_VFP_INSTR_FLDD, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return INT_MAX;
		stran = &instr->operands.vfp_stran;
		stran->ccode = SUBTILIS_ARM_CCODE_NV;
		stran->dest = i;
		stran->base = 13;
		stran->offset = 2;
		stran->pre_indexed = false;
		stran->write_back = true;
		stran->subtract = false;

		if (ldf_site == INT_MAX)
			ldf_site = arm_s->last_op;
	}

	return ldf_site;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x7fffffff, -0x40(%rbp) # imm = 0x7FFFFFFF
movl $0xf, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0xa00db
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x49, %esi
callq 0x6fb60
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa0067
movq $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jmp 0xa00e3
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0xf, (%rax)
movslq -0x24(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq $0xd, 0x10(%rax)
movq -0x38(%rbp), %rax
movb $0x2, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x1a(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1b(%rax)
cmpq $0x7fffffff, -0x40(%rbp) # imm = 0x7FFFFFFF
jne 0xa00cb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xa00cd
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa0032
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)