LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9d8, %rsp            # imm = 0x9D8
movapd 0xe6b(%rip), %xmm0      # 0x2010
movq %rsp, %r14
movapd %xmm0, (%r14)
leaq 0x14(%rsp), %rbx
movq %rbx, %rdi
callq 0x1080
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
leaq 0xe5d(%rip), %rdi       # 0x202e
callq 0x1050
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
leaq 0xe3d(%rip), %r14       # 0x2020
xorl %ebp, %ebp
xorl %r12d, %r12d
movl %r12d, %eax
imulq %r15, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %eax
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
subl %eax, %r13d
movq %rbx, %rdi
callq 0x1060
movq %r14, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
cmpl %ebp, %r13d
jne 0x1222
movl $0xa, %edi
callq 0x1030
incl %r12d
decl %ebp
cmpl $0xfffffc18, %ebp       # imm = 0xFFFFFC18
jne 0x11e8
leaq 0xe19(%rip), %rdi       # 0x204f
callq 0x1050
xorl %ebp, %ebp
movl $0xcccccccd, %r15d      # imm = 0xCCCCCCCD
leaq 0x14(%rsp), %rbx
leaq 0xdd7(%rip), %r14       # 0x2026
xorl %r12d, %r12d
movl %r12d, %eax
imulq %r15, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %eax
movl $0xfffffffc, %r13d      # imm = 0xFFFFFFFC
subl %eax, %r13d
movq %rbx, %rdi
callq 0x1060
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0xd85(%rip), %xmm0      # 0x2008
movq %r14, %rdi
movb $0x1, %al
callq 0x1070
cmpl %ebp, %r13d
jne 0x129c
movl $0xa, %edi
callq 0x1030
incl %r12d
decl %ebp
cmpl $0xfffffc18, %ebp       # imm = 0xFFFFFC18
jne 0x1252
xorl %eax, %eax
addq $0x9d8, %rsp            # imm = 0x9D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq %rsp, %r14
xorl %ebp, %ebp
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3240
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3340
cmpl $-0x1, %eax
jne 0x6bd9
movq %rbx, %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x30e0
movl $0x1, %ebp
testl %eax, %eax
jne 0x6be7
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x39e9
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x2c47a(%rip), %rsi     # 0x341c1
callq 0x3480
testq %rax, %rax
je 0x7d53
popq %rbx
retq
movq %rbx, %rdi
callq 0x3cc4
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x8(%rdi), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
andl 0x8(%rsi), %ecx
cmpl %ecx, %eax
jne 0xad42
testl %eax, %eax
je 0xad3f
movq 0x10(%rdi), %rcx
movq 0x10(%rsi), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
cmpl %edi, (%rcx,%rsi,4)
jne 0xad42
incq %rsi
cmpq %rsi, %rax
jne 0xad2f
xorl %eax, %eax
retq
seta %al
movzbl %al, %eax
sbbl $0x0, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x1080
testl %eax, %eax
je 0x136f
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
leaq 0xced(%rip), %rdi       # 0x2020
xorl %eax, %eax
callq 0x1070
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1120
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x10b0
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x8, %edi
movl $0x2, %esi
callq 0x31d8
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x321f
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq $0x2710, %rax           # imm = 0x2710
jb 0x482a
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x4891
xorl %r14d, %r14d
xorl %esi, %esi
movq %rbx, %rdi
callq 0x3327
addq (%rax), %r14
movq 0x8(%rsp), %rsi
incq %rsi
movq %rsi, 0x8(%rsp)
cmpq 0x10(%rbx), %rsi
jb 0x4864
xorl %ebp, %ebp
cmpq $0x2fadcf8, %r14        # imm = 0x2FADCF8
setne %bpl
jmp 0x4896
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x3457
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl $0x8, %edi
movl $0x2, %esi
callq 0x31d8
movq %rax, %rbx
leaq 0x510d(%rip), %r14      # 0x99e0
movq %rsp, %r15
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x80, %esi
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2130
movl $0x80, %esi
movq %r15, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x32c6
incl %ebp
cmpl $0x64, %ebp
jne 0x48d8
cmpq $0x0, 0x10(%rbx)
je 0x49bb
leaq 0x509d(%rip), %r14      # 0x99e0
movq %rsp, %r15
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x80, %esi
movq %r15, %rdi
movq %r14, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x2130
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3327
movq (%rax), %r13
movl $0x80, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
jne 0x49d7
movq %r13, %rdi
callq 0x2030
incl %r12d
cmpq %r12, 0x10(%rbx)
ja 0x4949
movq %rbx, %rdi
callq 0x3457
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5005(%rip), %rdi      # 0x99e3
leaq 0x5023(%rip), %rsi      # 0x9a08
leaq 0x5029(%rip), %rcx      # 0x9a15
movl $0x45, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x8, %edi
movl $0x2, %esi
callq 0x31d8
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x321f
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1869f, %rax          # imm = 0x1869F
jb 0x4a1c
movq %rbx, %rdi
callq 0x3340
movl $0x1, %ebp
testl %eax, %eax
je 0x4a7b
movq 0x8(%rsp), %rsi
decq %rsi
movq %rsi, 0x8(%rsp)
cmpq 0x10(%rbx), %rsi
jb 0x4a79
movq %rbx, %rdi
callq 0x3327
movq 0x8(%rsp), %rcx
cmpq (%rax), %rcx
je 0x4a52
jmp 0x4a7b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
leaq 0x5117(%rip), %rsi      # 0x9bb0
movq %rsp, %rbx
movl $0xc, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x0, 0x62(%rbx)
movw $0xa0d, 0x60(%rbx)      # imm = 0xA0D
leaq 0x68(%rsp), %r14
movl $0x258, %edx            # imm = 0x258
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7f3d
movl $0x1, %ebx
testl %eax, %eax
jne 0x4b1c
movq 0x298(%rsp), %r14
movq %rsp, %rdi
callq 0x20e0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2170
cmpq %r15, %rax
jne 0x4b1c
movq 0x2b0(%rsp), %rax
xorl %ebx, %ebx
orq 0x2a8(%rsp), %rax
setne %bl
movl %ebx, %eax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x2c0, %rsp            # imm = 0x2C0
leaq 0x50e2(%rip), %rsi      # 0x9c20
movq %rsp, %rbx
movl $0xc, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x68(%rsp), %r14
movl $0x258, %edx            # imm = 0x258
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7f3d
movl $0x1, %ebx
testl %eax, %eax
jne 0x4bda
movq %rsp, %rdx
leaq 0x68(%rsp), %rcx
movl $0x10, %edi
movl $0x10, %esi
callq 0x8058
testl %eax, %eax
jne 0x4bda
movq 0x298(%rsp), %r14
movq %rsp, %rdi
callq 0x20e0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2170
cmpq %r15, %rax
je 0x4bda
cmpq $0x0, 0x2a8(%rsp)
sete %al
cmpq $0x0, 0x2b0(%rsp)
sete %cl
orb %al, %cl
movzbl %cl, %ebx
movl %ebx, %eax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x308, %rsp            # imm = 0x308
leaq 0x5086(%rip), %rsi      # 0x9c80
leaq 0x10(%rsp), %rbx
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0xb0(%rsp), %r14
movl $0x258, %edx            # imm = 0x258
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7f3d
movl $0x1, %ebx
testl %eax, %eax
jne 0x4c73
leaq 0x10(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movl $0xb, %edi
movl $0xb, %esi
callq 0x8058
testl %eax, %eax
jne 0x4c73
leaq 0xb0(%rsp), %rdi
callq 0x8123
testl %eax, %eax
je 0x4c80
movl %ebx, %eax
addq $0x308, %rsp            # imm = 0x308
popq %rbx
popq %r14
retq
movq 0x300(%rsp), %rdi
testq %rdi, %rdi
je 0x4c73
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, (%rsp)
leaq 0x4d90(%rip), %rsi      # 0x9a32
movl $0x4, %edx
callq 0x2c23
movl $0x1, %ebx
testq %rax, %rax
je 0x4c73
movq 0x8(%rsp), %rdx
leaq 0x578c(%rip), %rsi      # 0xa44e
movq %rax, %rdi
callq 0x2080
testl %eax, %eax
jne 0x4c73
movq 0x300(%rsp), %rdi
leaq 0x4d5a(%rip), %rsi      # 0x9a37
movq %rsp, %rcx
movl $0x2, %edx
callq 0x2c23
testq %rax, %rax
je 0x4c73
movq (%rsp), %rdx
leaq 0x4d40(%rip), %rsi      # 0x9a3a
movq %rax, %rdi
callq 0x2080
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
jmp 0x4c73
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
leaq 0x5001(%rip), %rsi      # 0x9d20
movq %rsp, %rbx
movl $0xe, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x7d2266, 0x70(%rbx)   # imm = 0x7D2266
leaq 0x80(%rsp), %r14
movl $0x258, %edx            # imm = 0x258
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7f3d
movl $0x1, %ebx
testl %eax, %eax
jne 0x4db5
movq %rsp, %rdx
leaq 0x80(%rsp), %rcx
movl $0x10, %edi
movl $0x10, %esi
callq 0x8058
testl %eax, %eax
jne 0x4db5
movq 0x2c0(%rsp), %r14
movq %r14, %rdi
callq 0x20e0
cmpq $0x10, %rax
jne 0x4db5
testq %r14, %r14
sete %al
cmpq $0x10, 0x2c8(%rsp)
setne %cl
orb %al, %cl
movzbl %cl, %ebx
movl %ebx, %eax
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
leaq 0x4fc9(%rip), %rsi      # 0x9da0
movq %rsp, %rbx
movl $0xd, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x0, 0x68(%rbx)
leaq 0x70(%rsp), %r14
movl $0x258, %edx            # imm = 0x258
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7f3d
movl $0x1, %ebx
testl %eax, %eax
jne 0x4e97
movq %rsp, %rdx
leaq 0x70(%rsp), %rcx
movl $0x6, %edi
movl $0x6, %esi
callq 0x8058
testl %eax, %eax
jne 0x4e97
movq 0x2a0(%rsp), %r15
movq 0x2b0(%rsp), %r14
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x4e97
movq %rsp, %rdi
callq 0x20e0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x2170
addq $-0x6, %r12
cmpq %r12, %rax
jne 0x4e97
cmpq $0x0, 0x2b8(%rsp)
je 0x4e97
leaq 0x4bb7(%rip), %rsi      # 0x9a3f
movq %r14, %rdi
callq 0x21d0
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x2d0, %rsp            # imm = 0x2D0
leaq 0x4f55(%rip), %rsi      # 0x9e10
movq %rsp, %rbx
movl $0xe, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x0, 0x72(%rbx)
movw $0xa0d, 0x70(%rbx)      # imm = 0xA0D
leaq 0x78(%rsp), %r14
movl $0x258, %edx            # imm = 0x258
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x7f3d
movl $0x1, %ebx
testl %eax, %eax
jne 0x4f3e
movq 0x2a8(%rsp), %r14
movq %rsp, %rdi
callq 0x20e0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2170
cmpq %r15, %rax
jne 0x4f3e
movq 0x2c0(%rsp), %rax
xorl %ebx, %ebx
orq 0x2b8(%rsp), %rax
setne %bl
movl %ebx, %eax
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x12a8, %rsp           # imm = 0x12A8
movl $0x0, 0x4(%rsp)
cmpl $0x2, %edi
jb 0x7641
movq %rsi, %rbx
movslq %edi, %rbp
addq $-0x2, %rbp
addq $0x8, %rbx
movl $0x0, 0x4(%rsp)
leaq 0x2a86(%rip), %r14      # 0xa031
leaq 0x58(%rsp), %r15
leaq 0x8(%rsp), %r12
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4150
movq %rax, %r13
testq %rax, %rax
je 0x7625
movq %r13, %rdi
movq %r15, %rsi
callq 0x7af8
testl %eax, %eax
js 0x7637
movq %r13, %rdi
callq 0x4090
movq %r12, %rdi
callq 0x454c
movq %r15, %rdi
movq %r12, %rsi
callq 0x7f48
movq (%rbx), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x7230
movq %r12, %rdi
callq 0x4627
movq %r15, %rdi
callq 0x7fad
subq $0x1, %rbp
setb %al
testq %r13, %r13
je 0x7641
addq $0x8, %rbx
testb %al, %al
je 0x75b5
jmp 0x7641
movq %rbx, %rdi
callq 0x4345
movl $0x1, 0x4(%rsp)
jmp 0x760f
movq %rbx, %rdi
callq 0x4321
jmp 0x75d7
movl 0x4(%rsp), %eax
addq $0x12a8, %rsp           # imm = 0x12A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x40(%rsp), %r13d
movl %r13d, %edi
movl %r13d, %esi
callq 0x49798
movq %rax, (%r14)
leaq 0x4cd83(%rip), %rdi     # 0x55954
callq 0x2090
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2382e
leaq 0x4cd7d(%rip), %rdi     # 0x55966
callq 0x2090
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x23bd0
leaq 0x4cd75(%rip), %rdi     # 0x55979
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movslq %edx, %r13
imulq $0xc8, %r13, %rdi
callq 0x21d0
movq %rax, %r12
testl %r13d, %r13d
jle 0x8ca4
xorl %r13d, %r13d
movslq (%r15), %rax
imulq $0x70, %rax, %rax
movl 0x6c(%r14,%rax), %edx
movslq 0x4(%r15), %rcx
imulq $0x70, %rcx, %rcx
cmpl 0x6c(%r14,%rcx), %edx
jne 0x8c97
addq %r14, %rax
addq %r14, %rcx
movl 0x64(%rax), %eax
subl 0x64(%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x2, %ecx
ja 0x8c97
movslq %r13d, %r13
imulq $0xc8, %r13, %rdi
addq %r12, %rdi
movl $0xc8, %edx
movq %r15, %rsi
callq 0x21a0
incl %r13d
addq $0xc8, %r15
decl %ebp
jne 0x8c47
jmp 0x8ca7
xorl %r13d, %r13d
movl %r13d, (%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
jle 0x8d5a
movl %r8d, %r15d
movq %rcx, %rbp
movq %rsi, %rbx
movl %r8d, %r12d
movl %edx, %r9d
addq $0x34, %rbp
movl $0x1, 0x4(%rsp)
xorl %r14d, %r14d
movq %rdi, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movl $0x0, %r13d
testl %r15d, %r15d
jle 0x8d22
movb (%rbx,%r14), %al
movq %rbp, %rdx
xorl %r13d, %r13d
cmpb %al, (%rdx)
je 0x8d22
incq %r13
addq $0x70, %rdx
cmpq %r13, %r12
jne 0x8d0f
movl %r12d, %r13d
cmpl %r15d, %r13d
jne 0x8d4c
movsbl (%rbx,%r14), %esi
movl $0x0, 0x4(%rsp)
leaq 0x4c0cc(%rip), %rdi     # 0x54e07
xorl %eax, %eax
callq 0x20f0
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %rdi
movl %r13d, (%rdi,%r14,4)
incq %r14
cmpq %r9, %r14
jne 0x8cfa
jmp 0x8d62
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x38(%rsp)
movl %ecx, %ebp
movq %rdx, 0x60(%rsp)
movq %rsi, %rbx
movl %edi, %r14d
callq 0x20b0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x30(%rsp)
movq 0xc0(%rsp), %rdx
movq 0xe8(%rsp), %rcx
movl %r14d, 0x44(%rsp)
movl %r14d, %edi
movq %rbx, %rsi
movq %rcx, 0x58(%rsp)
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x4a4d2
callq 0x20b0
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
subss 0x30(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x5f1c1(%rip), %xmm0    # 0x685e0
leaq 0x4b985(%rip), %rdi     # 0x54dab
movb $0x1, %al
callq 0x20f0
callq 0x20b0
movq %rax, 0x48(%rsp)
movslq 0xa0(%rsp), %r13
movl %r13d, 0xb0(%rsp)
testq %r13, %r13
jle 0x94f2
leaq 0x1b8(%rsp), %r12
leaq 0x170(%rsp), %rax
leaq 0xa0(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq %rsi, 0x30(%rsp)
movq 0x40(%rcx), %r15
movq 0x38(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x40(%rax), %rbx
xorl %r14d, %r14d
movq (%r15,%r14,8), %rdi
movq 0x58(%rsp), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdx
movq 0x50(%rsp), %rcx
movl 0x44(%rsp), %r8d
movl %ebp, %r9d
callq 0x2445c
movq 0x30(%rsp), %rax
movq (%rax,%r14,8), %rdi
movq (%r15,%r14,8), %rdx
movupd (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
movq 0x60(%rsp), %rcx
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x2607f
incq %r14
cmpq %r14, %r13
jne 0x9485
xorps %xmm0, %xmm0
cvtsi2ssq 0x48(%rsp), %xmm0
movss %xmm0, 0x38(%rsp)
callq 0x20b0
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
subss 0x38(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x5f0bf(%rip), %xmm0    # 0x685e0
leaq 0x4b8ae(%rip), %rdi     # 0x54dd6
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/main_tnm.c
// Function: Get_modes_Cart
void Get_modes_Cart(struct Normal_Mode NM, int N_modes,
		    double **Hessian, struct Jacobian J,
		    struct axe *axe1, int naxe1, struct Reference Ref_kin)
{
  float t0=clock();
  d_Diagonalize(N_modes, Hessian, NM.omega2, NM.Cart, -1);
  printf("Hessian diagonalization. Time= %.2lf sec.\n", (clock()-t0)/nbtops);
  t0=clock();
    
  //  Convert normal modes
  struct Tors D_NM;
  D_NM.N_axes=naxe1;
  D_NM.N_Cart=NM.N_Cart;
  D_NM.coeff=malloc(1*sizeof(float));
  for(int ia=0; ia<NM.N; ia++){
    // Normalize_vector_weighted(NM.Cart[ia], Ref_kin.mass_coord, N_modes);
    D_NM.Cart=NM.Cart[ia];
    D_NM.Tors=NM.Tors[ia];
    D_NM.MW_Tors=NM.MW_Tors[ia];
    Convert_cart2torsion(&D_NM, Ref_kin, &J);
    NM.Tors_frac[ia]=Tors_fraction(&D_NM, Ref_kin.mass_coord);
  }
  printf("Torsional and Cartesian modes. Time= %.2lf sec.\n",
	 (clock()-t0)/nbtops);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movl %edi, %r15d
callq 0x20b0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x30(%rsp)
movq 0xe0(%rsp), %rdx
movq 0xf8(%rsp), %rcx
movl %r15d, %edi
movq %r14, %rsi
movq %rcx, 0x38(%rsp)
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x4a4d2
callq 0x20b0
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
subss 0x30(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x5f035(%rip), %xmm0    # 0x685e0
leaq 0x4b7f9(%rip), %rdi     # 0x54dab
movb $0x1, %al
callq 0x20f0
callq 0x20b0
movq %rax, 0x40(%rsp)
movl %ebp, 0x48(%rsp)
movl 0xcc(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl $0x4, %edi
callq 0x21d0
movq %rax, 0x68(%rsp)
movslq 0xc0(%rsp), %r14
testq %r14, %r14
jle 0x9686
leaq 0x1d8(%rsp), %rbp
leaq 0xc0(%rsp), %rax
movq 0x40(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq 0x48(%rax), %r15
movq 0x60(%rax), %rbx
xorl %r13d, %r13d
leaq 0x48(%rsp), %r12
movq 0x38(%rsp), %rax
movq (%rax,%r13,8), %rax
movq %rax, 0x50(%rsp)
movq 0x30(%rsp), %rax
movq (%rax,%r13,8), %rax
movq %rax, 0x60(%rsp)
movq (%r15,%r13,8), %rax
movq %rax, 0x58(%rsp)
movupd (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r12, %rdi
leaq 0x190(%rsp), %rsi
callq 0x26677
movq 0x18(%rbp), %rsi
movq %r12, %rdi
callq 0x26abe
movss %xmm0, (%rbx,%r13,4)
incq %r13
cmpq %r13, %r14
jne 0x961b
xorps %xmm0, %xmm0
cvtsi2ssq 0x40(%rsp), %xmm0
movss %xmm0, 0x38(%rsp)
callq 0x20b0
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
subss 0x38(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x5ef2b(%rip), %xmm0    # 0x685e0
leaq 0x4b71a(%rip), %rdi     # 0x54dd6
movb $0x1, %al
callq 0x20f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/main_tnm.c
// Function: Rescale_para
void Rescale_para(float kappa)
{
  printf("Rescaling force constant by factor %.4g\n", kappa);
  KAPPA*=kappa;
  K_PSI*=kappa; K_PHI*=kappa; K_OMEGA*=kappa; K_CHI*=kappa;
  K_BA*=kappa; K_BL*=kappa;
  K0=KAPPA*pow(C0,EXP_HESSIAN);
}

// Assembly:
subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x48549(%rip), %rdi     # 0x51ef2
movb $0x1, %al
callq 0x20f0
movss 0x14(%rsp), %xmm0
mulss 0x5f6ba(%rip), %xmm0    # 0x69078
movss %xmm0, 0x5f6b2(%rip)    # 0x69078
movaps %xmm0, %xmm1
movsd 0x5f6c7(%rip), %xmm0    # 0x69098
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, 0x5f6b5(%rip)    # 0x69098
movsd 0x5f6b5(%rip), %xmm0    # 0x690a0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x5f6a9(%rip)    # 0x690a0
movsd 0x5f691(%rip), %xmm0    # 0x69090
mulsd %xmm2, %xmm0
movsd %xmm0, 0x5f685(%rip)    # 0x69090
movsd 0x5f695(%rip), %xmm0    # 0x690a8
mulsd %xmm2, %xmm0
movsd %xmm0, 0x5f689(%rip)    # 0x690a8
movsd 0x5f689(%rip), %xmm0    # 0x690b0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x5f67d(%rip)    # 0x690b0
mulsd 0x5f67d(%rip), %xmm2    # 0x690b8
movsd %xmm2, 0x5f675(%rip)    # 0x690b8
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x5f619(%rip), %xmm0    # 0x69074
xorps %xmm1, %xmm1
cvtss2sd 0x5f606(%rip), %xmm1    # 0x6906c
callq 0x20a0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x5f607(%rip)    # 0x69080
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/main_tnm.c
// Function: Rescale_Hessian
double Rescale_Hessian(struct Normal_Mode NM,
		       struct interaction *Int_list, int N_int, 
		       float kappa, int anharmonic)
{

  // rescale interactions
  for(int i=0; i<N_int; i++)Int_list[i].sec_der*=kappa;

  double sum_sigma2=0; int i;
  printf("Rescaling omega2 by factor %.3g\n", kappa);

  // rescale modes
  for(i=0; i<NM.N; i++){
    if(anharmonic==0){
      NM.omega2[i]*=kappa;
      NM.sigma2[i]/=kappa;
      if(NM.select[i]==0){NM.omega[i]=0;}
      else{NM.omega[i]=sqrt(NM.omega2[i]);}
      sum_sigma2+=NM.sigma2[i];
    }else{
      NM.sigma2_anhar[i]/=kappa;
      sum_sigma2+=NM.sigma2_anhar[i];
    }
  }
  return(sum_sigma2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
leaq 0x50(%rsp), %r12
movss %xmm0, (%rsp)
cvtss2sd %xmm0, %xmm0
testl %esi, %esi
jle 0x9ac7
movl %esi, %eax
imulq $0xc8, %rax, %rax
xorl %ecx, %ecx
movsd 0x28(%rdi,%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rdi,%rcx)
addq $0xc8, %rcx
cmpq %rcx, %rax
jne 0x9aab
leaq 0x4844d(%rip), %rdi     # 0x51f1b
movb $0x1, %al
callq 0x20f0
movslq (%r12), %r14
testq %r14, %r14
jle 0x9bbc
movq 0x88(%r12), %r15
movq 0x18(%r12), %rax
movq 0x20(%r12), %r13
movq 0x28(%r12), %rbp
movq 0xc0(%r12), %rcx
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
xorps %xmm3, %xmm3
movss (%rsp), %xmm1
movl %ebx, 0x4(%rsp)
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
je 0x9b2f
movss (%r15,%r12,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%r15,%r12,4)
jmp 0x9ba6
movss (%r13,%r12,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r13,%r12,4)
movss (%rbp,%r12,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rbp,%r12,4)
cmpl $0x0, (%rcx,%r12,4)
je 0x9b6c
movss (%r13,%r12,4), %xmm0
ucomiss %xmm3, %xmm0
jb 0x9b71
sqrtss %xmm0, %xmm0
jmp 0x9b99
xorps %xmm0, %xmm0
jmp 0x9b99
movsd %xmm2, 0x10(%rsp)
movq %rcx, %rbx
callq 0x21c0
xorps %xmm3, %xmm3
movq %rbx, %rcx
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ebx
movsd 0x10(%rsp), %xmm2
movss (%rsp), %xmm1
movss %xmm0, (%rax,%r12,4)
movss (%rbp,%r12,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm2
incq %r12
cmpq %r12, %r14
jne 0x9b19
jmp 0x9bc0
xorpd %xmm2, %xmm2
movapd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/main_tnm.c
// Function: Write_ref_coord_d
void Write_ref_coord_d(double *coords, int N_ref, atom *atoms, int *atom_num)
{
  double *coord=coords;
  for(int i=0; i<N_ref; i++){
    double *r=atoms[atom_num[i]].r;
    for(int j=0; j<3; j++){*coord=*r; coord++; r++;}
  }
}

// Assembly:
testl %esi, %esi
jle 0xc776
movl %esi, %eax
xorl %esi, %esi
movslq (%rcx,%rsi,4), %r8
imulq $0x70, %r8, %r9
addq %rdx, %r9
xorl %r8d, %r8d
movsd (%r9,%r8), %xmm0
movsd %xmm0, (%rdi,%r8)
addq $0x8, %r8
cmpl $0x18, %r8d
jne 0xc755
incq %rsi
addq %r8, %rdi
cmpq %rax, %rsi
jne 0xc747
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: GetPdbId
void GetPdbId(char *pdb_file_in, char *pdbid){
     /* This subroutine pretends to get the
        PDB id from a pdb file name, and ressembles
	quite a lot my "old-and-dirty-Perl" days */

  int start=0, end=0, i,j; //end2=0

  for(i=strlen(pdb_file_in)-1;i>=0;i--){
    if (pdb_file_in[i]=='.'){
      end=i-1;
    }else if (pdb_file_in[i]=='/'){
      start=i+1; //end2=i-1;
      break;
    }
  }
  j=0;
  for (i=start;i<=end;i++){
    pdbid[j]=pdb_file_in[i];
    j++;
  }
  pdbid[j]='\0';
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20d0
movl %eax, %ecx
decl %ecx
js 0xdcc2
xorl %ecx, %ecx
leal -0x1(%rax), %edx
movzbl (%r14,%rdx), %esi
cmpl $0x2e, %esi
je 0xdcb5
cmpl $0x2f, %esi
jne 0xdcba
jmp 0xdcc6
addl $-0x2, %eax
movl %eax, %ecx
movl %edx, %eax
testl %edx, %edx
jg 0xdca1
jmp 0xdcc4
xorl %ecx, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xdcce
xorl %eax, %eax
jmp 0xdcea
movl %eax, %edx
subl %eax, %ecx
incl %ecx
addq %rdx, %r14
xorl %eax, %eax
movb (%r14,%rax), %dl
movb %dl, (%rbx,%rax)
incq %rax
cmpq %rax, %rcx
jne 0xdcd9
movl %eax, %eax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: Order_atoms
int Order_atoms(atom *atoms, int natoms, struct residue *seq, int Nres)
{
  int ires;
  for(ires=0; ires<Nres; ires++){
    struct residue *res=seq+ires;
    if((res->type==1)||(res->type==-1)){
      // Store side chain before CO
      Order_atoms_aa(res->atom_ptr, res->n_atom);
    }
  }
  return(1);
}

// Assembly:
testl %ecx, %ecx
jle 0xe0d9
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %ecx, %r14d
shlq $0x5, %r14
xorl %r15d, %r15d
movzwl 0x18(%rbx,%r15), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0xe0bd
cmpl $0x1, %eax
jne 0xe0cb
movq (%rbx,%r15), %rdi
movl 0x8(%rbx,%r15), %esi
callq 0xfc90
addq $0x20, %r15
cmpq %r15, %r14
jne 0xe0ab
popq %rbx
popq %r14
popq %r15
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: Find_PDB_order
void Find_PDB_order(atom *atoms, int N_atoms)
{
  int i, i_next, res=atoms[0].res, ares=0, i2=0, i_min;
  int i_max=N_atoms+1000;
  atom *atom1=atoms, *atom2;
  for(i=0; i<N_atoms; i++){
    atom1=atoms+i;
    if(atom1->res > res){ares=i; res=atom1->res;}
    i_min=i_max; i_next=atom1->i_num+1;
    atom2=atoms+ares; i2=ares;
    while((i2<N_atoms)&&(atom2->res==res)){
      if((atom2->i_num>=i_next)&&(atom2->i_num<i_min)){
	i_min=i2; if(i_min==i_next)break;
      }
      atom2++; i2++;
    }
    if(i_min < i_max){atom1->i_next=i_min;}
    else if(i2<N_atoms){atom1->i_next=i2;}
    else{atom1->i_next=-1;}
  }
}

// Assembly:
testl %esi, %esi
jle 0xe1e7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leal 0x3e8(%rsi), %eax
movl 0x64(%rdi), %ecx
movl %esi, %edx
movq %rdx, -0x8(%rsp)
leaq 0xd4(%rdi), %rdx
movq %rdx, -0x10(%rsp)
xorl %r9d, %r9d
xorl %r11d, %r11d
movl %r11d, %edx
imulq $0x70, %r9, %rbx
movl 0x64(%rdi,%rbx), %r8d
cmpl %ecx, %r8d
cmovgl %r8d, %ecx
movl %r9d, %r11d
cmovlel %edx, %r11d
cmpl %esi, %r11d
setl %bpl
jge 0xe19c
movslq %r11d, %rdx
imulq $0x70, %rdx, %r12
cmpl %ecx, 0x64(%rdi,%r12)
jne 0xe19c
movl 0x50(%rdi,%rbx), %r8d
leal 0x1(%r11), %r15d
movl %r8d, %r10d
negl %r10d
addq -0x10(%rsp), %r12
movl %r11d, %r14d
movl %eax, %r13d
movl -0x84(%r12), %edx
cmpl %r8d, %edx
jle 0xe17d
cmpl %r13d, %edx
jge 0xe17d
leal (%r10,%r15), %edx
cmpl $0x2, %edx
je 0xe1d2
leal -0x1(%r15), %r13d
cmpl %esi, %r15d
setl %bpl
je 0xe1cd
incl %r15d
leaq 0x70(%r12), %rdx
incl %r14d
cmpl %ecx, (%r12)
movq %rdx, %r12
je 0xe15e
jmp 0xe1a2
movl %r11d, %r14d
movl %eax, %r13d
addq %rdi, %rbx
testb $0x1, %bpl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovel %edx, %r14d
cmpl %eax, %r13d
cmovll %r13d, %r14d
movl %r14d, 0x4c(%rbx)
incq %r9
cmpq -0x8(%rsp), %r9
jne 0xe113
jmp 0xe1dd
movl %esi, %r14d
jmp 0xe1a2
decl %r15d
movl %r15d, %r14d
movl %r15d, %r13d
jmp 0xe1a2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: Open_compressed_file
FILE *Open_compressed_file(char *name, int *Compression)
{
  FILE *file_in;
  printf("Reading %s ", name);
  *Compression=Get_compression(name);
  char command[200];
  if(*Compression){
    sprintf(command, "%s %s > %s\n", PDBCAT, name, PDBTMP);
    system(command);
    file_in=fopen(PDBTMP, "r");
  }else{
    file_in=fopen(name, "r");
  }
  if(file_in==NULL){
    printf("\nERROR, %s not found\n", name); return(NULL);
  }
  return(file_in);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x47caf(%rip), %rdi     # 0x55eb0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x2(%rbx), %rax
movzbl -0x2(%rax), %ecx
cmpl $0x2e, %ecx
je 0xe21e
testl %ecx, %ecx
jne 0xe229
jmp 0xe22e
cmpb $0x67, -0x1(%rax)
jne 0xe229
cmpb $0x7a, (%rax)
je 0xe241
incq %rax
jmp 0xe20f
movl $0x0, (%r14)
leaq 0x4bc9e(%rip), %rsi     # 0x59eda
movq %rbx, %rdi
jmp 0xe282
movl $0x1, (%r14)
leaq 0x47b70(%rip), %rsi     # 0x55dbf
leaq 0x47b75(%rip), %rdx     # 0x55dcb
leaq 0x47b73(%rip), %r14     # 0x55dd0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x2260
movq %r15, %rdi
callq 0x20e0
leaq 0x4bc5b(%rip), %rsi     # 0x59eda
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
testq %rax, %rax
jne 0xe2a3
leaq 0x47b42(%rip), %rdi     # 0x55dd8
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
movq %r14, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: Check_chain
int Check_chain(int *ichain, int *sel, int *na, int ini_r, int nres)
{
  int del;
  if(*na < MIN_ATOM){
    int j; for(j=ini_r; j< nres; j++)sel[j]=0;
    del=1;
  }else{
    (*ichain)++; del=0;
  }
  *na=0;
  return(del);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdx), %eax
cmpl 0x589d3(%rip), %eax     # 0x68614
jge 0xfc6a
movl $0x1, %ebp
cmpl %r8d, %ecx
jge 0xfc6e
movslq %ecx, %rax
leaq (%rsi,%rax,4), %rdi
notl %ecx
addl %r8d, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x2110
jmp 0xfc6e
incl (%rdi)
xorl %ebp, %ebp
movl $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: Store_chain
void Store_chain(struct chain *chp, int *ichain, int n, int *nr)
{
  (*ichain)++; 
  chp->natoms=n-chp->ini_atom;
  chp->nres=*nr; 
  *nr=0;
}

// Assembly:
incl (%rsi)
subl (%rdi), %edx
movl %edx, 0x4(%rdi)
movl (%rcx), %eax
movl %eax, 0x1c(%rdi)
movl $0x0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/read.c
// Function: Store_branch
int Store_branch(atom **atom2, char BRANCH,
		 atom *res_atom, int n_atom)
{
  atom *atom1=res_atom; int i, n=0;
  for(i=0; i<n_atom; i++){
    if(atom1->name[1]==BRANCH){
      n+=Copy_atom(atom2, res_atom, i);
    }
    atom1++;
  }
  return(n);
}

// Assembly:
testl %ecx, %ecx
jle 0x10370
movl %esi, %r9d
movq %rdi, %r8
movl %ecx, %eax
imulq $0x70, %rax, %r10
xorl %r11d, %r11d
xorl %eax, %eax
cmpb %r9b, 0x19(%rdx,%r11)
jne 0x10366
movq (%r8), %rdi
leaq (%rdx,%r11), %rsi
movl $0xe, %ecx
rep  movsq (%rsi), %es:(%rdi)
addq $0x70, (%r8)
incl %eax
addq $0x70, %r11
cmpq %r11, %r10
jne 0x1034a
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ugobas[P]tnm/atoms.c
// Function: Atom_type
int Atom_type(char *name){
  if(init==0){
    num_BB=8;
    strcpy(BB_name[0],"N ");
    strcpy(BB_name[1],"CA");
    strcpy(BB_name[2],"C ");
    strcpy(BB_name[3],"CB");
    strcpy(BB_name[4],"O ");
    strcpy(BB_name[5],"CG");
    strcpy(BB_name[6],"OG");
    strcpy(BB_name[7],"SG");

    BB_length[0]=1.3301; BB_angle[0]=1.1091; // C-N,  CA-C-N
    BB_length[1]=1.4572; BB_angle[1]=1.0196; // N-CA, C-N-CA
    BB_length[2]=1.5236; BB_angle[2]=1.2018; // CA-C, N-CA-C
    BB_length[3]=1.5319; BB_angle[3]=1.2162; // CA-CB,N-CA-CB
    BB_length[4]=1.2316; BB_angle[4]=1.0359; // C-O,  CA-C-O


    init=1;
  }
  for(int i=0; i<num_BB; i++){
    if((name[0]==BB_name[i][0])&&(name[1]==BB_name[i][1]))
      return(i);
  }
  return(-1);
}

// Assembly:
cmpl $0x0, 0x68ef5(%rip)     # 0x79270
jne 0x1043a
leaq 0x58260(%rip), %rax     # 0x685e8
movl $0x8, (%rax)
leaq 0x59a9b(%rip), %rax     # 0x69e30
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movw $0x204e, (%rax)         # imm = 0x204E
movb %cl, 0x5(%rax)
movw $0x4143, 0x3(%rax)      # imm = 0x4143
movb %cl, 0x8(%rax)
movw $0x2043, 0x6(%rax)      # imm = 0x2043
movb %cl, 0xb(%rax)
movw $0x4243, 0x9(%rax)      # imm = 0x4243
movb %cl, 0xe(%rax)
movw $0x204f, 0xc(%rax)      # imm = 0x204F
movb %cl, 0x11(%rax)
movw $0x4743, 0xf(%rax)      # imm = 0x4743
movb %cl, 0x14(%rax)
movw $0x474f, 0x12(%rax)     # imm = 0x474F
movb %cl, 0x17(%rax)
movw $0x4753, 0x15(%rax)     # imm = 0x4753
leaq 0x59a6b(%rip), %rax     # 0x69e50
movl $0x3faa40b8, (%rax)     # imm = 0x3FAA40B8
leaq 0x59a7e(%rip), %rcx     # 0x69e70
movl $0x3f8df6fd, (%rcx)     # imm = 0x3F8DF6FD
movl $0x3fba8588, 0x4(%rax)  # imm = 0x3FBA8588
movl $0x3f828241, 0x4(%rcx)  # imm = 0x3F828241
movl $0x3fc30553, 0x8(%rax)  # imm = 0x3FC30553
movl $0x3f99d495, 0x8(%rcx)  # imm = 0x3F99D495
movl $0x3fc4154d, 0xc(%rax)  # imm = 0x3FC4154D
movl $0x3f9bac71, 0xc(%rcx)  # imm = 0x3F9BAC71
movl $0x3f9da512, 0x10(%rax) # imm = 0x3F9DA512
movl $0x3f84985f, 0x10(%rcx) # imm = 0x3F84985F
movl $0x1, 0x68e36(%rip)     # 0x79270
leaq 0x581a7(%rip), %rax     # 0x685e8
movslq (%rax), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x10478
leaq 0x599db(%rip), %rdx     # 0x69e30
incq %rdx
movb (%rdi), %r8b
xorl %esi, %esi
cmpb -0x1(%rdx), %r8b
jne 0x1046c
movb 0x1(%rdi), %r9b
cmpb (%rdx), %r9b
je 0x10479
incq %rsi
addq $0x3, %rdx
cmpq %rsi, %rcx
jne 0x1045d
retq
movl %esi, %eax
retq