LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/synthReadGen.c
// Function: NormalVal
double NormalVal(float mu, float sigma){
  double u, v, x, y, q;
  int stop = 0;
  while(stop == 0){
    u = rand()/( RAND_MAX + 1.0 );
    v = 1.7156*(rand()/( RAND_MAX + 1.0 ) - 0.5);
    x = u - 0.449871;
    y = abs(v) + 0.386595;
    q = sqrt(x) + y*(0.19600*y-0.25472*x);
    if( q > 0.27597 && ( q > 0.27846 || sqrt(v) > -4.0*log(u)*sqrt(u))){
      stop = 1;
    }
  }
  return mu + sigma*v/u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x17ae
callq 0x1160
cvtsi2sd %eax, %xmm0
movsd 0x29a4(%rip), %xmm1     # 0x4008
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x1160
cvtsi2sd %eax, %xmm1
movsd 0x298a(%rip), %xmm0     # 0x4008
divsd %xmm0, %xmm1
movsd 0x2996(%rip), %xmm0     # 0x4020
subsd %xmm0, %xmm1
movsd 0x29ba(%rip), %xmm0     # 0x4050
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x299c(%rip), %xmm1     # 0x4048
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x18(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x2973(%rip), %xmm1     # 0x4040
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x1150
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd 0x2943(%rip), %xmm3     # 0x4038
mulsd -0x20(%rbp), %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
movsd 0x2917(%rip), %xmm4     # 0x4030
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x28ed(%rip), %xmm1     # 0x4028
ucomisd %xmm1, %xmm0
jbe 0x17a9
movsd -0x30(%rbp), %xmm0
movsd 0x290a(%rip), %xmm1     # 0x4058
ucomisd %xmm1, %xmm0
ja 0x17a2
movsd -0x18(%rbp), %xmm0
callq 0x1150
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x1080
movaps %xmm0, %xmm1
movsd 0x28e8(%rip), %xmm0     # 0x4060
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x1150
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x17a9
movl $0x1, -0x34(%rbp)
jmp 0x1649
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd -0x18(%rbp), %xmm1
divsd -0x10(%rbp), %xmm1
addsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/synthReadGen.c
// Function: TruncatedNormal
double TruncatedNormal(float mu, float sigma, float min, float max){
  double val = NormalVal(mu, sigma);
  if(val < min){
    return min;
  }else if(val > max){
    return max;
  }else{
    return val;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
callq 0x1630
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1834
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1862
movsd -0x20(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1858
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1862
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sushant8421[P]create_your_own_shell/cwd.c
// Function: main
int main(int argc , char* argv[]) {
  char *buf;
  buf=(char *)malloc(100*sizeof(char));
  getcwd(buf,100);
  printf("Current Working Directory is : %s \n",buf);
  return 0 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x64, %edi
callq 0x1050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x64, %esi
callq 0x1040
movq -0x18(%rbp), %rsi
leaq 0xe67(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: clamp_grid_x
int
clamp_grid_x(int x)
{
	while (x < 0) {
		x += X_MAX;
	}
	while (x >= X_MAX) {
		x -= X_MAX;
	}
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2328
movl -0x4(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x2317
jmp 0x232a
cmpl $0x8, -0x4(%rbp)
jl 0x233b
movl -0x4(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x232a
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: clamp_grid_y
int
clamp_grid_y(int y)
{
	while (y < 0) {
		y += Y_MAX;
	}
	while (y >= Y_MAX) {
		y -= Y_MAX;
	}
	return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2358
movl -0x4(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x2347
jmp 0x235a
cmpl $0x8, -0x4(%rbp)
jl 0x236b
movl -0x4(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x235a
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: print_grid
void
print_grid()
{
	int x, y;
	
	for (y = 0; y < Y_MAX; ++y) {
		for (x = 0; x < X_MAX; ++x) {
			printf(" %c", get_grid_value(x, y));
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0x2471
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x2458
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2370
movl %eax, %esi
leaq 0x10bbe(%rip), %rdi     # 0x13004
movb $0x0, %al
callq 0x20d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x242c
leaq 0x12b50(%rip), %rdi     # 0x14faf
movb $0x0, %al
callq 0x20d0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x241f
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: count_neighbors
int
count_neighbors(int x, int y)
{
	int n = 0;
/*	if (get_grid_value(x + 0, y + 0) == FULL) ++n; */
	if (get_grid_value(x + 1, y + 0) == FULL) ++n;
	if (get_grid_value(x + 1, y + 1) == FULL) ++n;
	if (get_grid_value(x + 0, y + 1) == FULL) ++n;
	if (get_grid_value(x - 1, y + 1) == FULL) ++n;
	if (get_grid_value(x - 1, y + 0) == FULL) ++n;
	if (get_grid_value(x - 1, y - 1) == FULL) ++n;
	if (get_grid_value(x + 0, y - 1) == FULL) ++n;
	if (get_grid_value(x + 1, y - 1) == FULL) ++n;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
addl $0x0, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2ce4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
addl $0x1, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2d03
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl -0x8(%rbp), %esi
addl $0x1, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2d22
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
addl $0x1, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2d41
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
addl $0x0, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2d60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
subl $0x1, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2d7f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl -0x8(%rbp), %esi
subl $0x1, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2d9e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
subl $0x1, %esi
callq 0x2370
cmpl $0x6f, %eax
jne 0x2dbd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: ask_cell
BEH_DECL(ask_cell)
{
	CONS* msg = WHAT;
	CONS* x = map_get(msg, ATOM("x"));
	CONS* y = map_get(msg, ATOM("y"));
	CONS* state = MINE;
/*	CONS* request = map_get(state, ATOM("request")); */
/*	CONS* reply_to = map_get(state, ATOM("reply-to")); */
	CONS* cell;

	DBUG_ENTER("ask_cell");
	cell = get_cell(MK_INT(x), MK_INT(y));
	assert(actorp(cell));
	msg = state;
	DBUG_PRINT("", ("x=%d y=%d msg=%s", MK_INT(x), MK_INT(y), cons_to_str(msg)));
	SEND(cell, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xf020
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x10f77(%rip), %rdi     # 0x143b3
callq 0xb1f0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf840
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x1040c(%rip), %rdi     # 0x13870
callq 0xb1f0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf840
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xee90
movq %rax, %rdi
callq 0x4110
movq %rax, -0x28(%rbp)
leaq 0xfc5a(%rip), %rax      # 0x130f7
movq %rax, -0x58(%rbp)
leaq 0x14f40(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movl $0x125, -0x4c(%rbp)     # imm = 0x125
leaq 0x11aed(%rip), %rax     # 0x14fb0
movq %rax, -0x48(%rbp)
leaq 0x14d52(%rip), %rax     # 0x18220
movq %rax, -0x40(%rbp)
leaq 0x14f0f(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x11fa0
movq -0x18(%rbp), %rax
sarq $0x2, %rax
movl %eax, %edi
movq -0x20(%rbp), %rax
sarq $0x2, %rax
movl %eax, %esi
callq 0x2c60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3528
jmp 0x3547
leaq 0xfbd1(%rip), %rdi      # 0x13100
leaq 0xfb12(%rip), %rsi      # 0x13048
movl $0x127, %edx            # imm = 0x127
leaq 0xfbcb(%rip), %rcx      # 0x1310d
callq 0x20f0
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1563a(%rip), %rax     # 0x18b90
cmpl $0x0, (%rax)
je 0x35d0
leaq 0x14e86(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x11a40(%rip), %rcx     # 0x14fb0
movq %rcx, 0x10(%rax)
leaq 0x11a35(%rip), %rdi     # 0x14fb0
callq 0x113b0
cmpl $0x0, %eax
je 0x35d0
leaq 0x14e5c(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x129, 0xc(%rax)       # imm = 0x129
movq -0x18(%rbp), %rax
sarq $0x2, %rax
movl %eax, -0x70(%rbp)
movq -0x20(%rbp), %rax
sarq $0x2, %rax
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d60
movl -0x70(%rbp), %esi
movl -0x6c(%rbp), %edx
movq %rax, %rcx
leaq 0xfb5c(%rip), %rdi      # 0x13125
movb $0x0, %al
callq 0x12050
jmp 0x35d2
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5320
movl $0x12b, -0x4c(%rbp)     # imm = 0x12B
leaq -0x58(%rbp), %rdi
callq 0x12170
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: life_tick
void
life_tick(CONFIG* cfg)
{
	CONS* msg;
	CONS* actor;
	int n;

	DBUG_ENTER("life_tick");
	actor = CFG_ACTOR(cfg, ask_all_cells, NIL);

	msg = NIL;
	msg = map_put(msg, ATOM("request"), ATOM("gen-next"));
	CFG_SEND(cfg, actor, msg);

	n = run_configuration(cfg, 1000000);
	if (cfg->q_count > 0) {
		TRACE(printf("gen-next: queue length %d with %d budget remaining\n", cfg->q_count, n));
	}

	msg = NIL;
	msg = map_put(msg, ATOM("request"), ATOM("update-grid"));
	CFG_SEND(cfg, actor, msg);

	n = run_configuration(cfg, 1000000);
	if (cfg->q_count > 0) {
		TRACE(printf("update-grid: queue length %d with %d budget remaining\n", cfg->q_count, n));
	}

	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf588(%rip), %rax      # 0x1316b
movq %rax, -0x48(%rbp)
leaq 0x147fa(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x177, -0x3c(%rbp)     # imm = 0x177
leaq 0x113a7(%rip), %rax     # 0x14fb0
movq %rax, -0x38(%rbp)
leaq 0x1460c(%rip), %rax     # 0x18220
movq %rax, -0x30(%rbp)
leaq 0x147c9(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11fa0
movq -0x8(%rbp), %rdi
leaq -0x63e(%rip), %rsi      # 0x3600
leaq 0x14713(%rip), %rdx     # 0x18358
callq 0x5200
movq %rax, -0x18(%rbp)
leaq 0x14703(%rip), %rax     # 0x18358
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0xf422(%rip), %rdi      # 0x1308a
callq 0xb1f0
movq %rax, -0x50(%rbp)
leaq 0xf44f(%rip), %rdi      # 0x130c7
callq 0xb1f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0xf930
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5320
movq -0x8(%rbp), %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x5c20
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jle 0x3cd5
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
movl -0x1c(%rbp), %edx
leaq 0xf4a7(%rip), %rdi      # 0x13175
movb $0x0, %al
callq 0x20d0
leaq 0x1467c(%rip), %rax     # 0x18358
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0xf39b(%rip), %rdi      # 0x1308a
callq 0xb1f0
movq %rax, -0x60(%rbp)
leaq 0xf3bc(%rip), %rdi      # 0x130bb
callq 0xb1f0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0xf930
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5320
movq -0x8(%rbp), %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x5c20
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jle 0x3d5c
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
movl -0x1c(%rbp), %edx
leaq 0xf454(%rip), %rdi      # 0x131a9
movb $0x0, %al
callq 0x20d0
movl $0x18c, -0x3c(%rbp)     # imm = 0x18C
leaq -0x48(%rbp), %rdi
callq 0x12170
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: test_life
void
test_life(int counter)
{
	int n;
	CONFIG* cfg;

	DBUG_ENTER("test_life");
	TRACE(printf("--test_life--\n"));
	cfg = init_life();

	TRACE(printf("Initial Grid\n"));
	print_grid();
	
	for (n = 1; n < counter; ++n) {
		life_tick(cfg);
		TRACE(printf("Generation %d\n", n));
		print_grid();
	}

	report_actor_usage(cfg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
leaq 0xf44e(%rip), %rax      # 0x131e0
movq %rax, -0x38(%rbp)
leaq 0x1464b(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x195, -0x2c(%rbp)     # imm = 0x195
leaq 0x111f8(%rip), %rax     # 0x14fb0
movq %rax, -0x28(%rbp)
leaq 0x1445d(%rip), %rax     # 0x18220
movq %rax, -0x20(%rbp)
leaq 0x1461a(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11fa0
leaq 0xf401(%rip), %rdi      # 0x131ea
movb $0x0, %al
callq 0x20d0
callq 0x3900
movq %rax, -0x10(%rbp)
leaq 0xf3f9(%rip), %rdi      # 0x131f9
movb $0x0, %al
callq 0x20d0
callq 0x2410
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3e45
movq -0x10(%rbp), %rdi
callq 0x3bd0
movl -0x8(%rbp), %esi
leaq 0xf3d9(%rip), %rdi      # 0x13207
movb $0x0, %al
callq 0x20d0
callq 0x2410
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3e13
movq -0x10(%rbp), %rdi
callq 0x6c20
movl $0x1a3, -0x2c(%rbp)     # imm = 0x1A3
leaq -0x38(%rbp), %rdi
callq 0x12170
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/life.c
// Function: main
int
main(int argc, char** argv)
{
	int c;
	int counter = 35;

	DBUG_ENTER("main");
	DBUG_PROCESS(argv[0]);
	while ((c = getopt(argc, argv, "n:#:V")) != EOF) {
		switch(c) {
		case 'n':	counter = atoi(optarg);	break;
		case '#':	DBUG_PUSH(optarg);		break;
		case 'V':	banner();				exit(EXIT_SUCCESS);
		case '?':							usage();
		default:							usage();
		}
	}
	banner();

	test_life(counter);	/* this test involves running the dispatch loop */

	report_cons_stats();
	DBUG_RETURN (exit(EXIT_SUCCESS), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x23, -0x18(%rbp)
leaq 0xf330(%rip), %rax      # 0x13244
movq %rax, -0x40(%rbp)
leaq 0x144c9(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x1c2, -0x34(%rbp)     # imm = 0x1C2
leaq 0x11076(%rip), %rax     # 0x14fb0
movq %rax, -0x30(%rbp)
leaq 0x142db(%rip), %rax     # 0x18220
movq %rax, -0x28(%rbp)
leaq 0x14498(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11fa0
leaq 0x1447d(%rip), %rax     # 0x183e8
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x3f89
leaq 0x1446c(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x3f97
movq 0x14068(%rip), %rax     # 0x17ff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
leaq 0x14446(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq %rcx, 0x18(%rax)
callq 0x20a0
movl %eax, %ecx
leaq 0x14431(%rip), %rax     # 0x183e8
movq (%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x1441d(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xf269(%rip), %rdx      # 0x13249
callq 0x21b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x4073
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
subl $0x23, %eax
je 0x4030
jmp 0x3ffe
movl -0x4c(%rbp), %eax
subl $0x3f, %eax
je 0x4064
jmp 0x4008
movl -0x4c(%rbp), %eax
subl $0x56, %eax
je 0x4058
jmp 0x4012
movl -0x4c(%rbp), %eax
subl $0x6e, %eax
jne 0x4069
jmp 0x401c
movq 0x13fb5(%rip), %rax     # 0x17fd8
movq (%rax), %rdi
callq 0x21d0
movl %eax, -0x18(%rbp)
jmp 0x406e
jmp 0x4032
leaq 0x143af(%rip), %rax     # 0x183e8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1c7, 0xc(%rax)       # imm = 0x1C7
movq 0x13f8a(%rip), %rax     # 0x17fd8
movq (%rax), %rdi
callq 0x11640
jmp 0x406e
callq 0x3ec0
xorl %edi, %edi
callq 0x21f0
callq 0x3e90
callq 0x3e90
jmp 0x3fd2
callq 0x3ec0
movl -0x18(%rbp), %edi
callq 0x3d80
callq 0x3e70
movl $0x1d2, -0x34(%rbp)     # imm = 0x1D2
leaq -0x40(%rbp), %rdi
callq 0x12170
xorl %edi, %edi
callq 0x21f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/reverse.c
// Function: main
int main(void)
{
  char s[100] = "test";

  reverse(s);
  puts(s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x1050
movb $0x74, -0x70(%rbp)
movb $0x65, -0x6f(%rbp)
movb $0x73, -0x6e(%rbp)
movb $0x74, -0x6d(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x11b0
leaq -0x70(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aparrish[P]rwet-examples-c/cat.c
// Function: main
int main() {
	char* line = NULL;
	int len = 0;
	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);
		printf("%s", line);
		free(line);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x2e2b(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1050
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11cb
jmp 0x11fe
movq 0x2e0e(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1210
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xe18(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x11ae
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: put_loop
static void put_loop(ge_GIF *gif, uint16_t loop) {
    write(gif->fd, (uint8_t[]) { '!', 0xFF, 0x0B }, 3);
    write(gif->fd, "NETSCAPE2.0", 11);
    write(gif->fd, (uint8_t[]) { 0x03, 0x01 }, 2);
    write_num(gif->fd, loop);
    write(gif->fd, "\0", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movb $0x21, -0xd(%rbp)
movb $-0x1, -0xc(%rbp)
movb $0xb, -0xb(%rbp)
leaq -0xd(%rbp), %rsi
movl $0x3, %edx
callq 0x2070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x3a4b(%rip), %rsi      # 0x600d
movl $0xb, %edx
callq 0x2070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movb $0x3, -0xf(%rbp)
movb $0x1, -0xe(%rbp)
leaq -0xf(%rbp), %rsi
movl $0x2, %edx
callq 0x2070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x10(%rbp)
leaq -0x11(%rbp), %rsi
movl $0x2, %edx
callq 0x2070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x39fb(%rip), %rsi      # 0x601d
movl $0x1, %edx
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: ge_add_frame
void ge_add_frame(ge_GIF *gif, uint16_t delay) {
    uint16_t w, h, x, y;
    uint8_t *tmp;

    if (delay)
        set_delay(gif, delay);
    w = gif->w;
    h = gif->h;
    x = y = 0;
    put_image(gif, w, h, x, y);
    gif->nframes++;
    tmp = gif->back;
    gif->back = gif->frame;
    gif->frame = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
cmpw $0x0, -0xa(%rbp)
je 0x2667
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x26f0
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xe(%rbp)
movw $0x0, -0x12(%rbp)
movw $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movw -0xc(%rbp), %dx
movw -0xe(%rbp), %cx
movw -0x10(%rbp), %ax
movzwl %dx, %esi
movzwl %cx, %edx
movzwl %ax, %ecx
movzwl -0x12(%rbp), %r8d
callq 0x2780
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %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/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: new_trie
static Node *new_trie(int degree, int *nkeys) {
    Node *root = new_node(0, degree);
    /* Create nodes for single pixels. */
    for (*nkeys = 0; *nkeys < degree; (*nkeys)++)
        root->children[*nkeys] = new_node(*nkeys, degree);
    *nkeys += 2; /* skip clear code and stop code */
    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %esi
xorl %edi, %edi
callq 0x2c40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0x2b13
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl -0x4(%rbp), %esi
movzwl %ax, %edi
callq 0x2c40
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2ad7
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: new_node
static Node *new_node(uint16_t key, int degree) {
    Node *node = calloc(1, sizeof(*node) + degree * sizeof(Node *));
    if (node)
        node->key = key;
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x8(%rbp), %rsi
shlq $0x3, %rsi
addq $0x8, %rsi
movl $0x1, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c7e
movw -0x2(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: del_trie
static void del_trie(Node *root, int degree) {
    if (!root)
        return;
    for (int i = 0; i < degree; i++)
        del_trie(root->children[i], degree);
    free(root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2ca8
jmp 0x2ce0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2cd7
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
callq 0x2c90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2caf
movq -0x8(%rbp), %rdi
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: end_key
static void end_key(ge_GIF *gif) {
    int byte_offset;
    byte_offset = gif->offset / 8;
    if (gif->offset % 8)
        gif->buffer[byte_offset++] = gif->partial & 0xFF;
    write(gif->fd, (uint8_t[]) { byte_offset }, 1);
    write(gif->fd, gif->buffer, byte_offset);
    write(gif->fd, "\0", 1);
    gif->offset = gif->partial = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2d46
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, 0x2c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x2070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x2c, %rsi
movslq -0xc(%rbp), %rdx
callq 0x2070
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x3296(%rip), %rsi      # 0x601d
movl $0x1, %edx
callq 0x2070
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yahya-tamur[P]Visualising-Complex-Functions/params.cc
// Function: function(std::complex<long double>)
std::complex<long double> function(std::complex<long double> z) {
    std::complex<long double> ans = 0;
    for (long double i = 0; i < 100; i += 1) {
        ans += std::pow(std::complex<long double>(i, 0), -z);
    }
    return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rsp, %rax
fldz
fld %st(0)
fstpt -0x7c(%rbp)
fld %st(0)
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x3a30
fldt -0x7c(%rbp)
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
flds 0x574(%rip)             # 0x6120
fucompi %st(1), %st
fstp %st(0)
jbe 0x5c07
jmp 0x5bb4
fldt -0x10(%rbp)
movq %rsp, %rax
fldz
fstpt 0x10(%rax)
fstpt (%rax)
leaq -0x50(%rbp), %rdi
callq 0x3a30
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x5cb0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x5c20
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5d00
fldt -0x10(%rbp)
fld1
faddp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x5ba3
movq -0x90(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/bcast4.c
// Function: main
int
main(void)
{
    int i;
    long *target;
    static long source[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int nlong = 8;
    int me;

    shmem_init();
    me = shmem_my_pe();

    target = (long *) shmem_malloc(8 * sizeof(*target));

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }
    shmem_barrier_all();

    /* Number of PEs in the active set must be set properly, this test is
       expected to run with 4 PEs */
    if ((me % 2) == 0) {
        shmem_broadcast64(target, source, nlong, 0, 0, 1, 2, pSync);
    }

    shmem_barrier_all();

    for (i = 0; i < 8; i++) {
        printf("%d: target[%d] = %ld\n", me, i, target[i]);
    }

    shmem_free(target);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl $0x8, 0x14(%rsp)
callq 0x1080
callq 0x1050
movl %eax, 0x10(%rsp)
movl $0x40, %edi
callq 0x1060
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x2, 0x20(%rsp)
jge 0x1211
movslq 0x20(%rsp), %rcx
leaq 0x2ec4(%rip), %rax      # 0x40c0
movq $-0x1, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x11e9
callq 0x1070
movl 0x10(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x125c
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
leaq 0x2e38(%rip), %rsi      # 0x4070
xorl %r8d, %r8d
movl $0x1, %r9d
leaq 0x2e78(%rip), %rax      # 0x40c0
movl %r8d, %ecx
movl $0x2, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10a0
callq 0x1070
movl $0x0, 0x20(%rsp)
cmpl $0x8, 0x20(%rsp)
jge 0x12a1
movl 0x10(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xd77(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1269
movq 0x18(%rsp), %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unlink1.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	int i;
	tmpfiles = (char(*)[sizeof(template)])malloc(sizeof(template) * nr_tasks);
	assert(tmpfiles);

	for (i = 0; i < nr_tasks; i++) {
		strcpy(tmpfiles[i], template);
		char *tmpfile = tmpfiles[i];
		int fd = mkstemp(tmpfile);

		assert(fd >= 0);
		close(fd);
		unlink(tmpfile);
	}

	local_nr_tasks = nr_tasks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
imulq $0x18, -0x8(%rbp), %rdi
callq 0x21b0
movq %rax, 0xf1c3(%rip)      # 0x121b0
cmpq $0x0, 0xf1bb(%rip)      # 0x121b0
je 0x2ff9
jmp 0x3018
leaq 0x1288(%rip), %rdi      # 0x4288
leaq 0x128a(%rip), %rsi      # 0x4291
movl $0x14, %edx
leaq 0x128e(%rip), %rcx      # 0x42a1
callq 0x2120
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x30b3
movq 0xf17c(%rip), %rdi      # 0x121b0
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq 0x1280(%rip), %rsi      # 0x42c6
callq 0x2090
movq 0xf15e(%rip), %rax      # 0x121b0
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x3075
jmp 0x3094
leaq 0x1262(%rip), %rdi      # 0x42de
leaq 0x120e(%rip), %rsi      # 0x4291
movl $0x1b, %edx
leaq 0x1212(%rip), %rcx      # 0x42a1
callq 0x2120
movl -0x1c(%rbp), %edi
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x2080
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x301f
movq -0x8(%rbp), %rax
movl %eax, 0xf0fb(%rip)      # 0x121b8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unlink1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char *tmpfile = tmpfiles[nr];

	while (1) {
		int fd = open(tmpfile, O_RDWR|O_CREAT, 0600);
		assert(fd >= 0);
		close(fd);
		unlink(tmpfile);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xf0c9(%rip), %rax      # 0x121b0
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2210
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x3113
jmp 0x3132
leaq 0x11c4(%rip), %rdi      # 0x42de
leaq 0x1170(%rip), %rsi      # 0x4291
movl $0x2a, %edx
leaq 0x11b9(%rip), %rcx      # 0x42e6
callq 0x2120
movl -0x1c(%rbp), %edi
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x2080
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x30f3
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unlink1.c
// Function: testcase_cleanup
void testcase_cleanup(void)
{
	int i;
	for (i = 0; i < local_nr_tasks; i++) {
		unlink(tmpfiles[i]);
	}
	free(tmpfiles);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xf040(%rip), %eax      # 0x121b8
jge 0x319c
movq 0xf02f(%rip), %rdi      # 0x121b0
movslq -0x4(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x2080
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x316f
movq 0xf00d(%rip), %rdi      # 0x121b0
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./Utilities.h
// Function: growBuffer(char*&, int&)
void growBuffer(char *&buf, int &max_buffer) {
   int old_max = max_buffer;
   max_buffer *= 2;
   buf = (char *)realloc(buf, max_buffer * sizeof(char));

   // null terminate the new memory
   memset(&buf[old_max], '\0', max_buffer - old_max);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
shlq $0x0, %rsi
callq 0x22e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movslq 0x4(%rsp), %rax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
subl 0x4(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x20e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./Utilities.h
// Function: safeCopyToBuffer(char*&, char const*, int&, int&)
void safeCopyToBuffer(char *&dest_root, const char *source, int &index, int &max_buffer) {
   int len = strlen(source);
   if (len == 0) return;

   while (index + len >= max_buffer) {
      int old_max = max_buffer;
      max_buffer *= 2;
      dest_root = (char *)realloc(dest_root, max_buffer * sizeof(char));

      // null terminate the new memory
      memset(&dest_root[old_max], '\0', max_buffer - old_max);
   }

   strncpy(&dest_root[index], source, len);
   index += len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20a0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x2a42
jmp 0x2ae5
jmp 0x2a44
movq 0x10(%rsp), %rax
movl (%rax), %eax
addl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jl 0x2ab6
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rsi
shlq $0x0, %rsi
callq 0x22e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movslq (%rsp), %rax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
subl (%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x20e0
jmp 0x2a44
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movslq (%rax), %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movslq 0x4(%rsp), %rdx
callq 0x20c0
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::~OrderBook()
~OrderBook() {
      for (auto it = buy_book_map_.begin(); it != buy_book_map_.end(); ++it) {
         it->second.clearLevel();
      }
      for (auto it = sell_book_map_.begin(); it != sell_book_map_.end(); ++it) {
         it->second.clearLevel();
      }
      buy_book_map_.clear();
      sell_book_map_.clear();
      while (!orders_.empty()) {
         auto it = orders_.begin();
         delete it->second;
         orders_.erase(it);
      }
   }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0xd8, %rdi
callq 0x52c0
movq %rax, 0x48(%rsp)
movq 0x10(%rsp), %rdi
addq $0xd8, %rdi
callq 0x5310
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x52f0
testb $0x1, %al
jne 0x401f
jmp 0x4045
leaq 0x48(%rsp), %rdi
callq 0x5340
movq %rax, %rdi
addq $0x8, %rdi
callq 0x5370
jmp 0x4037
jmp 0x4039
leaq 0x48(%rsp), %rdi
callq 0x53f0
jmp 0x3ff4
movq 0x10(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x52c0
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x5310
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x52f0
testb $0x1, %al
jne 0x4086
jmp 0x40ac
leaq 0x38(%rsp), %rdi
callq 0x5340
movq %rax, %rdi
addq $0x8, %rdi
callq 0x5370
jmp 0x409e
jmp 0x40a0
leaq 0x38(%rsp), %rdi
callq 0x53f0
jmp 0x405b
movq 0x10(%rsp), %rdi
addq $0xd8, %rdi
callq 0x5420
movq 0x10(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x5420
movq 0x10(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x5430
xorb $-0x1, %al
testb $0x1, %al
jne 0x40e7
jmp 0x4154
movq 0x10(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x5450
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5480
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4120
movq 0x8(%rsp), %rdi
callq 0x21a0
movq 0x10(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x54a0
movq %rax, (%rsp)
jmp 0x4146
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x40ce
movq 0x10(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x54e0
movq 0x10(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x54f0
movq 0x10(%rsp), %rdi
addq $0xd8, %rdi
callq 0x54f0
movq 0x10(%rsp), %rdi
callq 0x5500
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x3b10
nop
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./CountedOrderList.h
// Function: OrderBook::CountedOrderList<OrderLevelEntry>::clearLevel()
void clearLevel() {
      NODE *head = DLList<NODE>::getHead();
      while (head != DLList<NODE>::getTail()) {
         removeNode(head);
         head = head->previous_;
      }
      removeNode(head);
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5670
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5680
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x53cd
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5690
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x538d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5690
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./Logger.h
// Function: Logger::~Logger()
~Logger() {
      // Guard against it never being used or being stopped elsewhere
      if (thread_ == 0) return;

      exit_ = true;
      thread_->join();
      delete thread_;
      thread_ = 0;
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x5524
movl $0x1, 0x1c(%rsp)
jmp 0x5580
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x6590
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x22f0
jmp 0x5543
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x556b
movq 0x8(%rsp), %rdi
callq 0x65c0
movq 0x8(%rsp), %rdi
callq 0x21a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x42e0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x42e0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x3b10
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./DLList.h
// Function: OrderBook::DLList<OrderLevelEntry>::removeNode(OrderLevelEntry*)
void removeNode(NODE *target) {
      // Skip self and delete if straddled
      if (target->previous_ != 0 && target->next_ != 0) {
         target->previous_->next_ = target->next_;
         target->next_->previous_ = target->previous_;
      }
      // Edge - tail deleted
      else if (target == tail_ && target->next_ != 0) {
         tail_ = target->next_;
         tail_->previous_ = 0;
      }
      // Edge - head deleted
      else if (target == head_ && target->previous_ != 0) {
         head_ = target->previous_;
         head_->next_ = 0;
      }
      // Edge - single element list
      else {
         head_ = 0;
         tail_ = 0;
         return;
      }
   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x572d
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x572d
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x57c0
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
cmpq 0x10(%rcx), %rax
jne 0x5769
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5769
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
movq $0x0, 0x20(%rax)
jmp 0x57be
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
cmpq 0x8(%rcx), %rax
jne 0x57a5
movq -0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x57a5
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
jmp 0x57bc
movq -0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x57c0
jmp 0x57be
jmp 0x57c0
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./MessageParser.h
// Function: OrderBook::MessageParser::getMessageType(char*)
inline MessageType MessageParser::getMessageType(char *tk_msg) {
   uint32_t len = strlen(tk_msg);
   if (len == 0 || len > MESSAGELENMAX) {
      FHErrorTracker::instance()->corruptMessage();
      return eMT_Unknown;
   }

   tk_msg = strtok(tk_msg, ",");
   switch(tk_msg[0]) {
      case 'A':
         return eMT_Add;
         break;
      case 'M':
         return eMT_Modify;
         break;
      case 'X':
         return eMT_Remove;
         break;
      case 'T':
         return eMT_Trade;
         break;
      default:
         return eMT_Unknown;
         break;
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x20a0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x677a
cmpl $0x24, 0xc(%rsp)
jbe 0x6791
callq 0x3a30
movq %rax, %rdi
callq 0x6810
movl $0x0, 0x24(%rsp)
jmp 0x6801
movq 0x10(%rsp), %rdi
leaq 0x9ac5(%rip), %rsi      # 0x10262
callq 0x22b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x17, %eax
ja 0x67f9
movq (%rsp), %rax
leaq 0x9840(%rip), %rcx      # 0x10008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, 0x24(%rsp)
jmp 0x6801
movl $0x3, 0x24(%rsp)
jmp 0x6801
movl $0x2, 0x24(%rsp)
jmp 0x6801
movl $0x4, 0x24(%rsp)
jmp 0x6801
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::addOrder(OrderLevelEntry*)
void addOrder(ORDERTYPE* ole) {
      checkCross();

      auto ooit = orders_.find(ole->order_id_);
      if (ooit != orders_.end()) {
         FHErrorTracker::instance()->duplicateAdd();
         delete ole;
         return;
      }

      OrderListMap &map = ole->order_side_ == eS_Buy ? buy_book_map_ : sell_book_map_;

      std::pair<typename OrderListMap::iterator, bool> ret;
      ret = map.insert(
         std::pair<unsigned long long, CountedOrderList<ORDERTYPE>>(
            ole->order_price_, CountedOrderList<ORDERTYPE>()));
      ret.first->second.addNode(ole);
      orders_[ole->order_id_] = ole;
   }

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0xb980
movq 0x40(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq 0xe8(%rsp), %rsi
callq 0xb830
movq 0x40(%rsp), %rdi
movq %rax, 0xe0(%rsp)
addq $0x138, %rdi            # imm = 0x138
callq 0xd920
movq %rax, 0xd8(%rsp)
leaq 0xe0(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0xd900
testb $0x1, %al
jne 0x753e
jmp 0x756d
callq 0x3a30
movq %rax, %rdi
callq 0xd950
movq 0xe8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x7568
movq 0x38(%rsp), %rdi
callq 0x21a0
jmp 0x76bd
movq 0xe8(%rsp), %rax
cmpl $0x1, 0x14(%rax)
jne 0x758d
movq 0x40(%rsp), %rax
addq $0xd8, %rax
movq %rax, 0x30(%rsp)
jmp 0x759d
movq 0x40(%rsp), %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0xd970
movq 0xd0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xe8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xd9f0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0xda30
jmp 0x75fd
movq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xd9a0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x761a
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movb %al, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xb0(%rsp)
movb 0x50(%rsp), %al
movb %al, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xda70
leaq 0x88(%rsp), %rdi
callq 0xdaa0
leaq 0x68(%rsp), %rdi
callq 0x5a00
leaq 0xc0(%rsp), %rdi
callq 0x5340
movq %rax, %rdi
addq $0x8, %rdi
movq 0xe8(%rsp), %rsi
callq 0xdac0
movq 0x40(%rsp), %rdi
movq 0xe8(%rsp), %rax
movq %rax, (%rsp)
addq $0x138, %rdi            # imm = 0x138
movq 0xe8(%rsp), %rsi
callq 0xdaf0
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x76f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xdaa0
leaq 0x68(%rsp), %rdi
callq 0x5a00
movq 0x60(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nop