LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs/storage_util.c
// Function: storage_util_unlock
int
storage_util_unlock(struct storage_state * S)
{
	int rc;

	/* Try to release the lock. */
	if ((rc = pthread_rwlock_unlock(&S->lck)) != 0) {
		warn0("pthread_rwlock_unlock: %s", strerror(rc));
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x23f0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x69a9
jmp 0x6983
movl -0x14(%rbp), %edi
callq 0x2530
movq %rax, %rsi
leaq 0xc48a(%rip), %rdi      # 0x12e1f
movb $0x0, %al
callq 0xf2c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x69b2
movl $0x0, -0x4(%rbp)
jmp 0x69b9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs/storage_util.c
// Function: storage_util_mkpath
char *
storage_util_mkpath(struct storage_state * S, uint64_t fileno)
{
	char * s;

	/* Construct path. */
	if (asprintf(&s, "%s/blks_%016" PRIx64,
	    S->storagedir, fileno) == -1) {
		warnp("asprintf");
		goto err0;
	}

	/* Success! */
	return (s);

err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %rdi
leaq 0xc443(%rip), %rsi      # 0x12e39
movb $0x0, %al
callq 0xb850
cmpl $-0x1, %eax
jne 0x6a3b
jmp 0x6a04
callq 0x20a0
cmpl $0x0, (%rax)
je 0x6a29
leaq 0xb8d0(%rip), %rdi      # 0x122e5
movb $0x0, %al
callq 0xf070
callq 0x20a0
movl $0x0, (%rax)
jmp 0x6a37
leaq 0xb8b5(%rip), %rdi      # 0x122e5
movb $0x0, %al
callq 0xf2c0
jmp 0x6a39
jmp 0x6a45
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a4d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs/disk.c
// Function: disk_syncdir
int
disk_syncdir(const char * path)
{
	int fd;

	while ((fd = open(path, O_RDONLY)) == -1) {
		if (errno != EINTR) {
			warnp("open(%s)", path);
			goto err0;
		}
	}
	while (fsync(fd)) {
		if (errno != EINTR) {
			warnp("fsync(%s)", path);
			goto err1;
		}
	}
	while (close(fd)) {
		if (errno != EINTR) {
			warnp("close(%s)", path);
			goto err0;
		}
	}

	/* Success! */
	return (0);

err1:
	if (close(fd))
		warnp("close");
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2480
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x6ad1
callq 0x20a0
cmpl $0x4, (%rax)
je 0x6acf
jmp 0x6a8d
callq 0x20a0
cmpl $0x0, (%rax)
je 0x6ab6
movq -0x10(%rbp), %rsi
leaq 0xcb6c(%rip), %rdi      # 0x1360e
movb $0x0, %al
callq 0xf070
callq 0x20a0
movl $0x0, (%rax)
jmp 0x6ac8
movq -0x10(%rbp), %rsi
leaq 0xcb4d(%rip), %rdi      # 0x1360e
movb $0x0, %al
callq 0xf2c0
jmp 0x6aca
jmp 0x6bda
jmp 0x6a6c
jmp 0x6ad3
movl -0x14(%rbp), %edi
callq 0x2460
cmpl $0x0, %eax
je 0x6b2d
callq 0x20a0
cmpl $0x4, (%rax)
je 0x6b2b
jmp 0x6aec
callq 0x20a0
cmpl $0x0, (%rax)
je 0x6b15
movq -0x10(%rbp), %rsi
leaq 0xc347(%rip), %rdi      # 0x12e48
movb $0x0, %al
callq 0xf070
callq 0x20a0
movl $0x0, (%rax)
jmp 0x6b27
movq -0x10(%rbp), %rsi
leaq 0xc328(%rip), %rdi      # 0x12e48
movb $0x0, %al
callq 0xf2c0
jmp 0x6b29
jmp 0x6b92
jmp 0x6ad3
jmp 0x6b2f
movl -0x14(%rbp), %edi
callq 0x2260
cmpl $0x0, %eax
je 0x6b89
callq 0x20a0
cmpl $0x4, (%rax)
je 0x6b87
jmp 0x6b48
callq 0x20a0
cmpl $0x0, (%rax)
je 0x6b71
movq -0x10(%rbp), %rsi
leaq 0xc2f5(%rip), %rdi      # 0x12e52
movb $0x0, %al
callq 0xf070
callq 0x20a0
movl $0x0, (%rax)
jmp 0x6b83
movq -0x10(%rbp), %rsi
leaq 0xc2d6(%rip), %rdi      # 0x12e52
movb $0x0, %al
callq 0xf2c0
jmp 0x6b85
jmp 0x6bda
jmp 0x6b2f
movl $0x0, -0x4(%rbp)
jmp 0x6be1
movl -0x14(%rbp), %edi
callq 0x2260
cmpl $0x0, %eax
je 0x6bd8
jmp 0x6ba1
callq 0x20a0
cmpl $0x0, (%rax)
je 0x6bc6
leaq 0xca72(%rip), %rdi      # 0x13624
movb $0x0, %al
callq 0xf070
callq 0x20a0
movl $0x0, (%rax)
jmp 0x6bd4
leaq 0xca57(%rip), %rdi      # 0x13624
movb $0x0, %al
callq 0xf2c0
jmp 0x6bd6
jmp 0x6bd8
jmp 0x6bda
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_rand.c
// Function: main
int
main (int argc VL_UNUSED, char *argv[] VL_UNUSED)
{
  int i ;
  vl_uint32 init [4] = {0x123, 0x234, 0x345, 0x456} ;
  VlRand rand ;
  vl_rand_init (&rand) ;

  vl_rand_seed_by_array (&rand, init, sizeof(init)/sizeof(init[0])) ;

  printf("1000 outputs of vl_rand_uint32()\n");
  for (i=0; i<1000; i++) {
    printf("%10" VL_FL_INT32 "u ", vl_rand_uint32(&rand));
    if (i%5==4) printf("\n");
  }

  printf("\n1000 outputs of vl_rand_real2()\n");
  for (i=0; i<1000; i++) {
    printf("%10.8f ", vl_rand_real2(&rand));
    if (i%5==4) printf("\n");
  }

  return 0;
}

// Assembly:
subq $0x9f8, %rsp            # imm = 0x9F8
movl $0x0, 0x9f4(%rsp)
movl %edi, 0x9f0(%rsp)
movq %rsi, 0x9e8(%rsp)
movq 0xe78(%rip), %rax       # 0x2010
movq %rax, 0x9d0(%rsp)
movq 0xe71(%rip), %rax       # 0x2018
movq %rax, 0x9d8(%rsp)
leaq 0xc(%rsp), %rdi
callq 0x1060
leaq 0x9d0(%rsp), %rsi
leaq 0xc(%rsp), %rdi
movl $0x4, %edx
callq 0x1030
leaq 0xe49(%rip), %rdi       # 0x2020
movb $0x0, %al
callq 0x1050
movl $0x0, 0x9e4(%rsp)
cmpl $0x3e8, 0x9e4(%rsp) # imm = 0x3E8
jge 0x1247
leaq 0xc(%rsp), %rdi
callq 0x1040
movl %eax, %esi
leaq 0xe39(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1050
movl 0x9e4(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x1232
leaq 0xe15(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1050
jmp 0x1234
movl 0x9e4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9e4(%rsp)
jmp 0x11e9
leaq 0xdfa(%rip), %rdi       # 0x2048
movb $0x0, %al
callq 0x1050
movl $0x0, 0x9e4(%rsp)
cmpl $0x3e8, 0x9e4(%rsp) # imm = 0x3E8
jge 0x12bc
leaq 0xc(%rsp), %rdi
callq 0x12d0
leaq 0xdec(%rip), %rdi       # 0x206a
movb $0x1, %al
callq 0x1050
movl 0x9e4(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x12a7
leaq 0xda0(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1050
jmp 0x12a9
movl 0x9e4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9e4(%rsp)
jmp 0x1260
xorl %eax, %eax
addq $0x9f8, %rsp            # imm = 0x9F8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/oatk.c
// Function: make_dir
static int make_dir(char *dir)
{
    struct stat st = {0};
    if (stat(dir, &st) == -1) {
        int ret = mkdir(dir, 0700);
        if (ret) {
            fprintf(stderr, "[W::%s] create output directory '%s' failed: %s\n", __func__, dir, strerror(errno));
            exit(EXIT_FAILURE);
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x3240
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3330
cmpl $-0x1, %eax
jne 0x5755
movq -0x10(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x30d0
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0x574c
movq 0x518fd(%rip), %rax     # 0x56ff8
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x3080
movl (%rax), %edi
callq 0x3590
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rcx
movq %rax, %r8
leaq 0x468dd(%rip), %rsi     # 0x4c011
leaq 0x46907(%rip), %rdx     # 0x4c042
movb $0x0, %al
callq 0x3320
movl $0x1, %edi
callq 0x3520
movl $0x1, -0x4(%rbp)
jmp 0x575c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path_finder.c
// Function: fopen1
FILE *fopen1(char *fn)
{
    FILE *fo;
    fo = fopen(fn, "w");
    if (!fo) {
        fprintf(stderr, "[E::%s] failed to open file %s to write\n", __func__, fn);
        exit(EXIT_FAILURE);
    }
    return fo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x45cca(%rip), %rsi     # 0x4d0a1
callq 0x3470
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7414
movq 0x4fc0a(%rip), %rax     # 0x56ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x45054(%rip), %rsi     # 0x4c450
leaq 0x45076(%rip), %rdx     # 0x4c479
movb $0x0, %al
callq 0x3320
movl $0x1, %edi
callq 0x3520
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path_finder.c
// Function: path_cmpfunc
static int path_cmpfunc(const void *a, const void *b)
{
    path_t *x, *y;
    x = (path_t *) a;
    y = (path_t *) b;
    if (x->nv != y->nv)
        return (x->nv > y->nv) - (x->nv < y->nv);

    uint32_t i, nv, *vx, *vy;
    nv = x->nv;
    vx = x->v;
    vy = y->v;

    for (i = 0; i < nv; ++i)
        if (vx[i] != vy[i])
            return (vx[i] > vy[i]) - (vx[i] < vy[i]);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rcx
movl 0x8(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
je 0xb32b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rcx
movl 0x8(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movl 0x8(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movq -0x28(%rbp), %rdx
movl 0x8(%rdx), %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
cmpl %edx, %ecx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xb3cb
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0xb3c4
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
je 0xb3b7
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
movq -0x40(%rbp), %rdx
movl -0x2c(%rbp), %esi
cmpl (%rdx,%rsi,4), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xb3cb
jmp 0xb3b9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb359
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path_finder.c
// Function: parse_subgraph
static lv_u32_t parse_subgraph(asg_t *asg)
{
    uint32_t i, j, n_seg, *vlist, nv;
    lv_u32_t lv_list;
    asmg_t *g;
    uint8_t *visited;

    g = asg->asmg;
    n_seg = asg->n_seg;
    kv_init(lv_list);
    MYCALLOC(visited, n_seg);
    for (i = 0; i < n_seg; ++i) {
        if (visited[i] || g->vtx[i].del) continue;
        vlist = asmg_subgraph(g, &i, 1, 0, 0, &nv, 0);
        assert(nv > 0);
        v_u32_t lv = {nv, nv, vlist};
        kv_push(v_u32_t, lv_list, lv);
        for (j = 0; j < nv; ++j)
            visited[vlist[j]] = 1;
    }
    free(visited);

    return lv_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x14(%rbp)
movq $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
movq $0x0, 0x10(%rdi)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x32d0
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xb75d
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xb62b
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb630
jmp 0xb74f
movq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x24(%rbp), %r9
movl $0x0, (%rsp)
callq 0x420a0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jbe 0xb660
jmp 0xb67f
leaq 0x41693(%rip), %rdi     # 0x4ccfa
leaq 0x40f90(%rip), %rsi     # 0x4c5fe
movl $0x4a, %edx
leaq 0x41687(%rip), %rcx     # 0x4cd01
callq 0x3220
movl -0x24(%rbp), %eax
movq %rax, -0x50(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0xb6ee
movq -0x60(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb6be
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x68(%rbp)
jmp 0xb6c9
movl $0x2, %eax
movq %rax, -0x68(%rbp)
jmp 0xb6c9
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
imulq $0x18, 0x8(%rax), %rsi
callq 0x33f0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rdx
movq 0x10(%rdx), %rax
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xb74d
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
movb $0x1, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb728
jmp 0xb74f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb5ef
movq -0x38(%rbp), %rdi
callq 0x3060
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path_finder.c
// Function: lv_u32_destroy
static void lv_u32_destroy(lv_u32_t *lv)
{
    size_t i;
    for (i = 0; i < lv->n; ++i)
        kv_destroy(lv->a[i]);
    kv_destroy(*lv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xb7b8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x3060
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb784
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tsoding[P]x11-double-buffering/././db_xdbe.c
// Function: db_init
void db_init(DB *db, Display *display, Window window)
{
    int major_version_return, minor_version_return;
    if(XdbeQueryExtension(display, &major_version_return, &minor_version_return)) {
        printf("XDBE version %d.%d\n", major_version_return, minor_version_return);
    } else {
        fprintf(stderr, "XDBE is not supported!!!1\n");
        exit(1);
    }

    db->display = display;
    db->window = window;
    db->gc = XCreateGC(display, window, 0, NULL);
    db->back_buffer = XdbeAllocateBackBufferName(display, window, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1070
cmpl $0x0, %eax
je 0x12e0
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
leaq 0xd2d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
jmp 0x1302
movq 0x2d11(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd27(%rip), %rsi       # 0x2018
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x1170
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x10a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/pwd.c
// Function: main
int main()
{

        char cwd[PATH_MAX];
        if (getcwd(cwd, sizeof(cwd)) != NULL) {
                printf("%s\n", cwd);
        } else {
                perror("getcwd() error");
        }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
movl $0x0, -0x4(%rbp)
leaq -0x1010(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x1040
cmpq $0x0, %rax
je 0x11a0
leaq -0x1010(%rbp), %rsi
leaq 0xe6d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x11ac
leaq 0xe61(%rip), %rdi       # 0x2008
callq 0x1050
movl -0x4(%rbp), %eax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/joltikneq80112v13/ref/joltik.c
// Function: set_block_number_in_tweak
static void set_block_number_in_tweak(uint8_t *tweak, const uint64_t block_no) {
    tweak[ 7] = (tweak[7]&0xf0) ^ ((block_no >> 48ULL) & 0xf);
    tweak[ 8] = ((block_no >> 40ULL) & 0xff);
    tweak[ 9] = ((block_no >> 32ULL) & 0xff);
    tweak[10] = ((block_no >> 24ULL) & 0xff);
    tweak[11] = ((block_no >> 16ULL) & 0xff);
    tweak[12] = ((block_no >>  8ULL) & 0xff);
    tweak[13] = ((block_no >>  0ULL) & 0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x7(%rax), %eax
andl $0xf0, %eax
cltq
movq -0x10(%rsp), %rcx
shrq $0x30, %rcx
andq $0xf, %rcx
xorq %rcx, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rsp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rsp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xb(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xc(%rax)
movq -0x10(%rsp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xd(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_vector
int test_vector() {
	vector *vec = vector_new(sizeof(uint64_t), 2);

	uint64_t i;
	for (i = 0; i < 10000; i++)
		vector_append(vec, &i, sizeof(i));

	uint64_t total = 0;
	for (i = 0; i < vec->count; i++) {
		uint64_t *j = (uint64_t *)vector_get(vec, i);
		total += *j;
	}

	vector_free(vec);

	if (total != 49995000)
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x8, %edi
movl $0x2, %esi
callq 0x3990
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x2710, -0x18(%rbp)    # imm = 0x2710
jae 0x5fbd
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x3a20
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5f93
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x600b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x3c60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5fcd
movq -0x10(%rbp), %rdi
callq 0x3e30
cmpq $0x2fadcf8, -0x20(%rbp) # imm = 0x2FADCF8
je 0x6027
movl $0x1, -0x4(%rbp)
jmp 0x602e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_vector_ptr_append
int test_vector_ptr_append() {
	vector *vec = vector_new(sizeof(uint64_t), 2);

	uint32_t i = 0;
	for (i = 0; i < 100; i++) {
		char buf[128] = {0};
		char *duped = NULL;
		snprintf(buf, sizeof(buf), "%u", i);
		duped = strndup(buf, sizeof(buf));

		vector_append_ptr(vec, duped);
	}

	for (i = 0; i < vec->count; i++) {
		char buf[128] = {0};
		snprintf(buf, sizeof(buf), "%u", i);

		char **str = (char **)vector_get(vec, i);

		assert(strncmp(buf, *str, sizeof(buf)) == 0);
		free(*str);
	}

	vector_free(vec);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x8, %edi
movl $0x2, %esi
callq 0x3990
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jae 0x60e0
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2150
movq $0x0, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x80, %esi
leaq 0x6929(%rip), %rdx      # 0xc9cf
movb $0x0, %al
callq 0x2120
leaq -0x90(%rbp), %rdi
movl $0x80, %esi
callq 0x21a0
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x3b80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x606c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x6199
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2150
leaq -0x120(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x80, %esi
leaq 0x68ae(%rip), %rdx      # 0xc9cf
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3c60
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x128(%rbp), %rax
movq (%rax), %rsi
movl $0x80, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x615d
jmp 0x617c
leaq 0x686e(%rip), %rdi      # 0xc9d2
leaq 0x688c(%rip), %rsi      # 0xc9f7
movl $0x45, %edx
leaq 0x688d(%rip), %rcx      # 0xca04
callq 0x2140
movq -0x128(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x60e7
movq -0x8(%rbp), %rdi
callq 0x3e30
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_vector_reverse
int test_vector_reverse() {
	vector *vec = vector_new(sizeof(uint64_t), 2);

	uint64_t i;
	for (i = 0; i < 99999; i++)
		vector_append(vec, &i, sizeof(i));

	if (!vector_reverse(vec))
		return 1;

	for (i -= 1; i >= vec->count; i--) {
		uint64_t *j = (uint64_t *)vector_get(vec, i);
		if (i != *j)
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x8, %edi
movl $0x2, %esi
callq 0x3990
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x1869f, -0x18(%rbp)   # imm = 0x1869F
jae 0x61fd
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x3a20
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x61d3
movq -0x10(%rbp), %rdi
callq 0x3cc0
cmpl $0x0, %eax
jne 0x6214
movl $0x1, -0x4(%rbp)
jmp 0x626e
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x6267
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x3c60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
je 0x6257
movl $0x1, -0x4(%rbp)
jmp 0x626e
jmp 0x6259
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6220
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_request_without_body_is_parseable
int test_request_without_body_is_parseable() {
	const unsigned char req[] = " GET / HTTP/1.1\r\n"
		"User-Agent: curl/7.35.0\r\n"
		"Host: localhost:8080\r\n"
		"Content-Length: 6\r\n"
		"Accept: */*\r\n\r\n";
	m38_http_request request = {
		.verb = {0},
		.resource = {0},
		.matches = {{0}},
		.full_header = NULL,
		.body_len = 0,
		.full_body = NULL
	};

	int rc = m38_parse_request(req, strlen((char *)req), &request);
	if (rc != 0)
		return 1;

	if (strnlen(request.full_header, strlen((char *)req)) != strlen((char *)req))
		return 1;
	if (request.full_body != NULL || request.body_len != 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
leaq -0x70(%rbp), %rdi
leaq 0x690a(%rip), %rsi      # 0xcba0
movl $0x63, %edx
callq 0x2210
leaq -0x2c8(%rbp), %rdi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
callq 0x2150
leaq -0x70(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq -0x2d8(%rbp), %rdi
movq %rax, %rsi
leaq -0x2c8(%rbp), %rdx
callq 0xac30
movl %eax, -0x2cc(%rbp)
cmpl $0x0, -0x2cc(%rbp)
je 0x62f5
movl $0x1, -0x4(%rbp)
jmp 0x6364
movq -0x98(%rbp), %rax
movq %rax, -0x2e8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq -0x2e8(%rbp), %rdi
movq %rax, %rsi
callq 0x2160
movq %rax, -0x2e0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x2e0(%rbp), %rax
cmpq %rcx, %rax
je 0x6343
movl $0x1, -0x4(%rbp)
jmp 0x6364
cmpq $0x0, -0x88(%rbp)
jne 0x6354
cmpq $0x0, -0x80(%rbp)
je 0x635d
movl $0x1, -0x4(%rbp)
jmp 0x6364
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_request_with_body_is_parseable_no_clength
int test_request_with_body_is_parseable_no_clength() {
	const unsigned char req[] = " GET / HTTP/1.1\r\n"
		"User-Agent: curl/7.35.0\r\n"
		"Host: localhost:8080\r\n"
		"Accept: */*\r\n\r\n"
		"{\"test\": \"asdf\"}";
	m38_http_request request = {
		.verb = {0},
		.resource = {0},
		.matches = {{0}},
		.full_header = NULL,
		.body_len = 0,
		.full_body = NULL
	};

	int rc = m38_parse_request(req, strlen((char *)req), &request);
	if (rc != 0)
		return 1;
	rc = m38_parse_body(strlen("{\"test\": \"asdf\"}"), 16, req, &request);
	if (rc != 0)
		return 1;

	if (strnlen(request.full_header, strlen((char *)req)) == strlen((char *)req))
		return 1;
	if (request.full_body == NULL || request.body_len <= 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
leaq -0x70(%rbp), %rdi
leaq 0x688a(%rip), %rsi      # 0xcc10
movl $0x60, %edx
callq 0x2210
leaq -0x2c8(%rbp), %rdi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
callq 0x2150
leaq -0x70(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq -0x2d8(%rbp), %rdi
movq %rax, %rsi
leaq -0x2c8(%rbp), %rdx
callq 0xac30
movl %eax, -0x2cc(%rbp)
cmpl $0x0, -0x2cc(%rbp)
je 0x63e8
movl $0x1, -0x4(%rbp)
jmp 0x6487
leaq -0x70(%rbp), %rdx
movl $0x10, %esi
leaq -0x2c8(%rbp), %rcx
movq %rsi, %rdi
callq 0xae10
movl %eax, -0x2cc(%rbp)
cmpl $0x0, -0x2cc(%rbp)
je 0x6418
movl $0x1, -0x4(%rbp)
jmp 0x6487
movq -0x98(%rbp), %rax
movq %rax, -0x2e8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq -0x2e8(%rbp), %rdi
movq %rax, %rsi
callq 0x2160
movq %rax, -0x2e0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x2e0(%rbp), %rax
cmpq %rcx, %rax
jne 0x6466
movl $0x1, -0x4(%rbp)
jmp 0x6487
cmpq $0x0, -0x88(%rbp)
je 0x6477
cmpq $0x0, -0x80(%rbp)
ja 0x6480
movl $0x1, -0x4(%rbp)
jmp 0x6487
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_form_encoded_body
int test_form_encoded_body() {
	const unsigned char req[] = " GET / HTTP/1.1\r\n"
		"User-Agent: curl/7.35.0\r\n"
		"Host: localhost:8080\r\n"
		"Accept: */*\r\n"
		"Content-Type: application/x-www-form-urlencoded\r\n"
		"Content-Length: 11\r\n\r\n"
		"test=1&23=a";
	m38_http_request request = {
		.verb = {0},
		.resource = {0},
		.matches = {{0}},
		.full_header = NULL,
		.body_len = 0,
		.full_body = NULL,
		.form_elements = NULL
	};

	int rc = m38_parse_request(req, strlen((char *)req), &request);
	if (rc != 0)
		return 1;
	rc = m38_parse_body(strlen("test=1&23=a"), 11, req, &request);
	if (rc != 0)
		return 1;
	rc = m38_parse_form_encoded_body(&request);
	if (rc != 0)
		return 1;

	if (!request.form_elements)
		return 1;

	const char *test_value = NULL, *a_value = NULL;
	size_t test_size = 0, a_size = 0;
	if (!(test_value = sparse_dict_get(request.form_elements, "test", strlen("test"), &test_size)))
		return 1;
	if (strncmp(test_value, "1", test_size) != 0)
		return 1;
	if (!(a_value = sparse_dict_get(request.form_elements, "23", strlen("23"), &a_size)))
		return 1;
	if (strncmp(a_value, "asdf", a_size) != 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
leaq -0xb0(%rbp), %rdi
leaq 0x67b7(%rip), %rsi      # 0xcc70
movl $0xa0, %edx
callq 0x2210
leaq -0x308(%rbp), %rdi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
callq 0x2150
leaq -0xb0(%rbp), %rax
movq %rax, -0x338(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x20d0
movq -0x338(%rbp), %rdi
movq %rax, %rsi
leaq -0x308(%rbp), %rdx
callq 0xac30
movl %eax, -0x30c(%rbp)
cmpl $0x0, -0x30c(%rbp)
je 0x6521
movl $0x1, -0x4(%rbp)
jmp 0x6684
leaq -0xb0(%rbp), %rdx
movl $0xb, %esi
leaq -0x308(%rbp), %rcx
movq %rsi, %rdi
callq 0xae10
movl %eax, -0x30c(%rbp)
cmpl $0x0, -0x30c(%rbp)
je 0x6557
movl $0x1, -0x4(%rbp)
jmp 0x6684
leaq -0x308(%rbp), %rdi
callq 0xaf80
movl %eax, -0x30c(%rbp)
cmpl $0x0, -0x30c(%rbp)
je 0x657e
movl $0x1, -0x4(%rbp)
jmp 0x6684
cmpq $0x0, -0xb8(%rbp)
jne 0x6594
movl $0x1, -0x4(%rbp)
jmp 0x6684
movq $0x0, -0x318(%rbp)
movq $0x0, -0x320(%rbp)
movq $0x0, -0x328(%rbp)
movq $0x0, -0x330(%rbp)
movq -0xb8(%rbp), %rdi
leaq 0x6453(%rip), %rsi      # 0xca21
movl $0x4, %edx
leaq -0x328(%rbp), %rcx
callq 0x3030
movq %rax, -0x318(%rbp)
cmpq $0x0, %rax
jne 0x65f8
movl $0x1, -0x4(%rbp)
jmp 0x6684
movq -0x318(%rbp), %rdi
movq -0x328(%rbp), %rdx
leaq 0x6e8d(%rip), %rsi      # 0xd49a
callq 0x2080
cmpl $0x0, %eax
je 0x6620
movl $0x1, -0x4(%rbp)
jmp 0x6684
movq -0xb8(%rbp), %rdi
leaq 0x63f8(%rip), %rsi      # 0xca26
movl $0x2, %edx
leaq -0x330(%rbp), %rcx
callq 0x3030
movq %rax, -0x320(%rbp)
cmpq $0x0, %rax
jne 0x6655
movl $0x1, -0x4(%rbp)
jmp 0x6684
movq -0x320(%rbp), %rdi
movq -0x330(%rbp), %rdx
leaq 0x63bf(%rip), %rsi      # 0xca29
callq 0x2080
cmpl $0x0, %eax
je 0x667d
movl $0x1, -0x4(%rbp)
jmp 0x6684
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_request_with_body_is_parseable
int test_request_with_body_is_parseable() {
	const unsigned char req[] = " GET / HTTP/1.1\r\n"
		"User-Agent: curl/7.35.0\r\n"
		"Host: localhost:8080\r\n"
		"Accept: */*\r\n"
		"Content-Length: 16\r\n\r\n"
		"{\"test\": \"asdf\"}";
	m38_http_request request = {
		.verb = {0},
		.resource = {0},
		.matches = {{0}},
		.full_header = NULL,
		.body_len = 0,
		.full_body = NULL
	};

	int rc = m38_parse_request(req, strlen((char *)req), &request);
	if (rc != 0)
		return 1;
	rc = m38_parse_body(strlen("{\"test\": \"asdf\"}"), 16, req, &request);
	if (rc != 0)
		return 1;

	if (strlen((const char *)request.full_body) != 16)
		return 1;
	if (request.full_body == NULL || request.body_len != 16)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
leaq -0x80(%rbp), %rdi
leaq 0x666a(%rip), %rsi      # 0xcd10
movl $0x74, %edx
callq 0x2210
leaq -0x2d8(%rbp), %rdi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
callq 0x2150
leaq -0x80(%rbp), %rax
movq %rax, -0x2e8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq -0x2e8(%rbp), %rdi
movq %rax, %rsi
leaq -0x2d8(%rbp), %rdx
callq 0xac30
movl %eax, -0x2dc(%rbp)
cmpl $0x0, -0x2dc(%rbp)
je 0x6705
movl $0x1, -0x4(%rbp)
jmp 0x6774
leaq -0x80(%rbp), %rdx
movl $0x10, %esi
leaq -0x2d8(%rbp), %rcx
movq %rsi, %rdi
callq 0xae10
movl %eax, -0x2dc(%rbp)
cmpl $0x0, -0x2dc(%rbp)
je 0x6735
movl $0x1, -0x4(%rbp)
jmp 0x6774
movq -0x98(%rbp), %rdi
callq 0x20d0
cmpq $0x10, %rax
je 0x6750
movl $0x1, -0x4(%rbp)
jmp 0x6774
cmpq $0x0, -0x98(%rbp)
je 0x6764
cmpq $0x10, -0x90(%rbp)
je 0x676d
movl $0x1, -0x4(%rbp)
jmp 0x6774
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_request_body_is_extracted
int test_request_body_is_extracted() {
	const unsigned char req[] = " GET / HTTP/1.1\r\n"
		"User-Agent: curl/7.35.0\r\n"
		"Host: localhost:8080\r\n"
		"Content-Length: 6\r\n"
		"Accept: */*\r\n\r\n"
		"Hello!";
	m38_http_request request = {
		.verb = {0},
		.resource = {0},
		.matches = {{0}},
		.full_header = NULL,
		.body_len = 0,
		.full_body = NULL
	};

	int rc = m38_parse_request(req, strlen((char *)req), &request);
	if (rc != 0)
		return 1;
	rc = m38_parse_body(strlen("Hello!"), 6, req, &request);
	if (rc != 0)
		return 1;

	if (request.full_header == NULL || request.full_body == NULL)
		return 1;
	if (strnlen(request.full_header, strlen((char *)req)) != strlen((char *)req) - 6)
		return 1;
	if (request.full_body == NULL || request.body_len <= 0)
		return 1;
	if (strcmp((char *)request.full_body, "Hello!") != 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
leaq -0x70(%rbp), %rdi
leaq 0x65fa(%rip), %rsi      # 0xcd90
movl $0x69, %edx
callq 0x2210
leaq -0x2c8(%rbp), %rdi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
callq 0x2150
leaq -0x70(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq -0x2d8(%rbp), %rdi
movq %rax, %rsi
leaq -0x2c8(%rbp), %rdx
callq 0xac30
movl %eax, -0x2cc(%rbp)
cmpl $0x0, -0x2cc(%rbp)
je 0x67f8
movl $0x1, -0x4(%rbp)
jmp 0x68df
leaq -0x70(%rbp), %rdx
movl $0x6, %esi
leaq -0x2c8(%rbp), %rcx
movq %rsi, %rdi
callq 0xae10
movl %eax, -0x2cc(%rbp)
cmpl $0x0, -0x2cc(%rbp)
je 0x682b
movl $0x1, -0x4(%rbp)
jmp 0x68df
cmpq $0x0, -0x98(%rbp)
je 0x683f
cmpq $0x0, -0x88(%rbp)
jne 0x684b
movl $0x1, -0x4(%rbp)
jmp 0x68df
movq -0x98(%rbp), %rax
movq %rax, -0x2e8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq -0x2e8(%rbp), %rdi
movq %rax, %rsi
callq 0x2160
movq %rax, -0x2e0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x2e0(%rbp), %rax
subq $0x6, %rcx
cmpq %rcx, %rax
je 0x689d
movl $0x1, -0x4(%rbp)
jmp 0x68df
cmpq $0x0, -0x88(%rbp)
je 0x68ae
cmpq $0x0, -0x80(%rbp)
ja 0x68b7
movl $0x1, -0x4(%rbp)
jmp 0x68df
movq -0x88(%rbp), %rdi
leaq 0x6169(%rip), %rsi      # 0xca2e
callq 0x21c0
cmpl $0x0, %eax
je 0x68d8
movl $0x1, -0x4(%rbp)
jmp 0x68df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/utests.c
// Function: test_range_header_weird_case
int test_range_header_weird_case() {
	const unsigned char req[] = " GET / HTTP/1.1\r\n"
		"User-Agent: curl/7.35.0\r\n"
		"Host: localhost:8080\r\n"
		"Content-Length: 6\r\n"
		"Range: 0-32768\r\n" // bytes=0-32768 Limit: 32768 Offset: 0
		"Accept: */*\r\n\r\n";
	m38_http_request request = {
		.verb = {0},
		.resource = {0},
		.matches = {{0}},
		.full_header = NULL,
		.body_len = 0,
		.full_body = NULL
	};

	int rc = m38_parse_request(req, strlen((char *)req), &request);
	if (rc != 0)
		return 1;

	if (strnlen(request.full_header, strlen((char *)req)) != strlen((char *)req))
		return 1;
	if (request.full_body != NULL || request.body_len != 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp            # imm = 0x300
leaq -0x80(%rbp), %rdi
leaq 0x64fa(%rip), %rsi      # 0xce00
movl $0x73, %edx
callq 0x2210
leaq -0x2d8(%rbp), %rdi
xorl %esi, %esi
movl $0x258, %edx            # imm = 0x258
callq 0x2150
leaq -0x80(%rbp), %rax
movq %rax, -0x2e8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq -0x2e8(%rbp), %rdi
movq %rax, %rsi
leaq -0x2d8(%rbp), %rdx
callq 0xac30
movl %eax, -0x2dc(%rbp)
cmpl $0x0, -0x2dc(%rbp)
je 0x6965
movl $0x1, -0x4(%rbp)
jmp 0x69d7
movq -0xa8(%rbp), %rax
movq %rax, -0x2f8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq -0x2f8(%rbp), %rdi
movq %rax, %rsi
callq 0x2160
movq %rax, -0x2f0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x2f0(%rbp), %rax
cmpq %rcx, %rax
je 0x69b3
movl $0x1, -0x4(%rbp)
jmp 0x69d7
cmpq $0x0, -0x98(%rbp)
jne 0x69c7
cmpq $0x0, -0x90(%rbp)
je 0x69d0
movl $0x1, -0x4(%rbp)
jmp 0x69d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/disasm.c
// Function: main
int main(int argc, const char* argv[]) {
    for (size_t i = 1; i < (size_t) argc; i++) {
        FILE* fd = fopen(argv[i], "rb");
        if (fd == NULL) {
            fprintf(stderr, "error: failed to open input file \"%s\"\n", argv[i]);
            return 1;
        }

        QstBin bin;
        int ret = read_bin(fd, &bin);
        if (ret < 0) {
            fprintf(stderr, "error: failed to read input file \"%s\"\n", argv[i]);
        }

        fclose(fd);

        Chunk chunk;
        init_chunk(&chunk);
        bin_to_chunk(&bin, &chunk);

        disassemble_chunk(&chunk, argv[i], false);

        free_chunk(&chunk);
        free_bin(&bin);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x12d0, %rsp           # imm = 0x12D0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jae 0x78f3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x4810(%rip), %rsi      # 0xc015
callq 0x4150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7845
movq 0x117dc(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4ed0(%rip), %rsi      # 0xc702
movb $0x0, %al
callq 0x4100
movl $0x1, -0x4(%rbp)
jmp 0x78f3
movq -0x20(%rbp), %rdi
leaq -0x1270(%rbp), %rsi
callq 0x81a0
movl %eax, -0x1274(%rbp)
cmpl $0x0, -0x1274(%rbp)
jge 0x7888
movq 0x1178d(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4ea8(%rip), %rsi      # 0xc729
movb $0x0, %al
callq 0x4100
movq -0x20(%rbp), %rdi
callq 0x4080
leaq -0x12c8(%rbp), %rdi
callq 0x4280
leaq -0x1270(%rbp), %rdi
leaq -0x12c8(%rbp), %rsi
callq 0x88e0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x12c8(%rbp), %rdi
xorl %edx, %edx
callq 0x7330
leaq -0x12c8(%rbp), %rdi
callq 0x4430
leaq -0x1270(%rbp), %rdi
callq 0x89a0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x77e1
movl -0x4(%rbp), %eax
addq $0x12d0, %rsp           # imm = 0x12D0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/main_tnm.c
// Function: Allocate_memory
void Allocate_memory(struct Normal_Mode *NM,
		     struct Jacobian *J,
		     double ***Hessian,
		     int N_axes, int N_ref, int N_Cart,
		     int N_modes, int N_res)
{

  // Hessian
  *Hessian=Allocate_mat2_d(N_modes, N_modes);
  printf("Hessian allocated\n");

  // Kinematics:
  Allocate_Jacobian(J, N_axes, N_Cart);
  printf("Jacobian allocated\n");

  // Normal modes
  Allocate_Normal_modes(NM, N_modes, N_axes, N_Cart);
  printf("Normal modes allocated\n");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl 0x10(%rbp), %edi
movl 0x10(%rbp), %esi
callq 0x694a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq 0x6cf03(%rip), %rdi     # 0x77754
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x31560
leaq 0x6cef9(%rip), %rdi     # 0x77767
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x31ba0
leaq 0x6ceed(%rip), %rdi     # 0x7777b
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/main_tnm.c
// Function: Unfold_interactions
struct interaction *Unfold_interactions(int *N_int_unfold,
					struct interaction *Int_list,
					int N_int, atom *atoms)
{
  struct interaction *Int_list_unfold=
    malloc(N_int*sizeof(struct interaction)), *tmp=Int_list;
  int DIJ_MIN=2, n=0;
  for(int k=0; k<N_int; k++){
    if(atoms[tmp->i1].chain==atoms[tmp->i2].chain &&
       abs(atoms[tmp->i1].res-atoms[tmp->i2].res)<=DIJ_MIN){
      Int_list_unfold[n]=*tmp; n++; 
    }
    tmp++;
  }
  *N_int_unfold=n;
  return(Int_list_unfold);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x14(%rbp), %rax
imulq $0xc8, %rax, %rdi
callq 0x1180
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa99d
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x6c(%rax), %eax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rdx
movslq 0x4(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x6c(%rcx), %eax
jne 0xa981
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %eax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rdx
movslq 0x4(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
subl 0x64(%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x34(%rbp), %eax
jg 0xa981
movq -0x28(%rbp), %rdi
movslq -0x38(%rbp), %rax
imulq $0xc8, %rax, %rax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movl $0xc8, %edx
callq 0x1160
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0xc8, %rax
movq %rax, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xa8e8
movl -0x38(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/main_tnm.c
// Function: Get_chain_num
int Get_chain_num(int *apo_chain_num, char *apo_chains, int n_apo,
		   struct chain *chains, int Nchain){
  int success=1;
  for(int i=0; i<n_apo; i++){
    int j;
    for(j=0; j<Nchain; j++)if(chains[j].label==apo_chains[i])break;
    if(j==Nchain){
      printf("ERROR, chain %c not found in PDB\n",apo_chains[i]);
      success=0;
    }
    apo_chain_num[i]=j;
  }
  return(success);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x1, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xaa6b
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xaa26
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movsbl 0x34(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xaa19
jmp 0xaa26
jmp 0xaa1b
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xa9ec
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0xaa4f
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x6ffe7(%rip), %rdi     # 0x7aa28
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x28(%rbp)
movl -0x30(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa9d9
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ugobas[P]tnm/main_tnm.c
// Function: Get_modes_tors
void Get_modes_tors(struct Normal_Mode NM, int N_modes,
		    double **Hessian, struct Jacobian J,
		    struct axe *axe1, int naxe1, struct Reference Ref_kin,
		    atom *atoms1)
{
  float t0=clock();

  d_Diagonalize(N_modes, Hessian, NM.omega2, NM.MW_Tors, -1);
  printf("Hessian diagonalization. Time= %.2lf sec.\n", (clock()-t0)/nbtops);
  t0=clock();

  // UGO: Rescale omega^2 with mass 09/08/2022 It may induce mistakes
  //float omega_norm=Ref_kin.mass_sum/Ref_kin.N_ref;
  //for(int i=0; i<N_modes; i++)NM.omega2[i]*=omega_norm;
  
  // Allocate only relevant modes
  NM.N_relevant=NM.N;
  for(int ia=0; ia<NM.N; ia++){
    Transform_tors_modes(NM.Tors[ia], NM.MW_Tors[ia],
			 J.T_sqrt_tr, J.T_sqrt_inv_tr,
			 N_modes, naxe1);
    Convert_torsion2cart(NM.Cart[ia], atoms1, NM.Tors[ia],
			 axe1, naxe1, Ref_kin, ia);
  }
  printf("Torsional and Cartesian modes. Time= %.2lf sec.\n",
	 (clock()-t0)/nbtops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x128(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xe0(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
callq 0x1090
movq %rax, %rcx
movq -0x38(%rbp), %rax
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq 0x20(%rax), %rdx
movq 0x48(%rax), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x6ac30
callq 0x1090
cvtsi2ss %rax, %xmm0
subss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x802ea(%rip), %xmm0    # 0x8b5a0
leaq 0x6f70f(%rip), %rdi     # 0x7a9cc
movb $0x1, %al
callq 0x10d0
callq 0x1090
movq %rax, %rcx
movq -0x38(%rbp), %rax
cvtsi2ss %rcx, %xmm0
movss %xmm0, -0x2c(%rbp)
movl (%rax), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0xb386
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x40(%rcx), %rdx
movslq -0x30(%rbp), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x48(%rcx), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x40(%rax), %rdx
movq 0x38(%rax), %rcx
movl -0x4(%rbp), %r8d
movl -0x1c(%rbp), %r9d
callq 0x32960
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq 0x38(%rcx), %rdx
movslq -0x30(%rbp), %rsi
movq (%rdx,%rsi,8), %rdi
movq -0x28(%rbp), %rsi
movq 0x40(%rcx), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl -0x30(%rbp), %r9d
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x35540
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xb2e6
callq 0x1090
cvtsi2ss %rax, %xmm0
subss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x801ff(%rip), %xmm0    # 0x8b5a0
leaq 0x6f64f(%rip), %rdi     # 0x7a9f7
movb $0x1, %al
callq 0x10d0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)