LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/PepiJK[P]Mail-Server-Client/src/myserver.cpp
// Function: main
int main(int argc, char *argv[])
{
   MyHelper helper;
   helper.checkServerArguments(argc, argv);

   MySocket serverSocket(stoi(argv[1]));
   serverSocket.createSocket();
   serverSocket.bindSocket();
   serverSocket.listenSocket();

   int new_socket;

   cout << "Waiting for connections..." << endl;
   while (1)
   {
      new_socket = serverSocket.acceptNewConnection();
      // create a new thread everytime a new client connects to the server
      // detach because we allow the execution of the thread to continue independently
      thread(serverThread, helper, ref(serverSocket), new_socket, argv[2]).detach();
   }
   return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp            # imm = 0x498
movq %rsi, %r15
movl %edi, %ebx
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x364c
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x365e
movq 0x8(%r15), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3110
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3bc3
leaq -0x4b8(%rbp), %rdi
movl %eax, %esi
callq 0x3fdc
leaq -0x58(%rbp), %rdi
callq 0x3150
leaq -0x4b8(%rbp), %rdi
callq 0x4036
leaq -0x4b8(%rbp), %rdi
callq 0x40e2
leaq -0x4b8(%rbp), %r14
movq %r14, %rdi
callq 0x410a
movq 0x46cb(%rip), %rdi      # 0x9fd0
leaq 0x1951(%rip), %rsi      # 0x725d
callq 0x32a0
movq %rax, %rdi
callq 0x3180
addq $0x10, %r15
leaq -0x58(%rbp), %r12
leaq -0x38(%rbp), %rbx
leaq -0x2c(%rbp), %r13
movq %r14, %rdi
callq 0x4132
movl %eax, -0x2c(%rbp)
movq %r14, -0x38(%rbp)
movq %r12, %rdi
leaq -0x1682(%rip), %rsi     # 0x42c0
leaq -0x88(%rbp), %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %r15, %r9
callq 0x5c46
movq %r12, %rdi
callq 0x3450
movq %r12, %rdi
callq 0x5cea
jmp 0x5929
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5cea
jmp 0x5980
jmp 0x597d
jmp 0x597d
jmp 0x597d
movq %rax, %rbx
leaq -0x4b8(%rbp), %rdi
callq 0x42ae
jmp 0x59a1
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3150
jmp 0x59a1
jmp 0x599e
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3b7e
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/razimantv[P]DancingLinks/sudoku/../DancingLinks/DancingLinks.cpp
// Function: DancingLinks::DancingLinks()
DancingLinks::DancingLinks() {
  dummycolumn_ = new DancingLinksColumn;
  dummycolumn_->set_essential(false);
  columns_ = NULL;
  cells_ = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x10c0
movq %rax, %r14
movq %rax, %rdi
callq 0x1fb4
movq %r14, (%rbx)
movb $0x0, 0x1c(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/razimantv[P]DancingLinks/sudoku/../DancingLinks/DancingLinks.cpp
// Function: DancingLinks::Destroy()
void DancingLinks::Destroy() {
  // Delete memory allocated to the children at the header
  // Of course, use this only at the header and only after allocation has
  //  been done. Don't blame me if you screw up
  if (columns_ != NULL) {
    delete[] columns_;
    columns_ = NULL;
  }
  if (cells_ != NULL) {
    delete[] cells_;
    cells_ = NULL;
  }
  dummycolumn_->set_left_ptr(NULL);
  dummycolumn_->set_right_ptr(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x1688
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x1670
addq $-0x20, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x1ffe
addq $-0x20, %r13
jne 0x1661
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1160
andq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x169b
callq 0x10f0
andq $0x0, 0x10(%rbx)
movq (%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::DancingLinksColumn()
DancingLinksColumn::DancingLinksColumn() {
  left_ptr_ = right_ptr_ = NULL;
  dummycell_ = new DancingLinksCell;
  size_ = 0;
  essential_ = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
pushq $0x30
popq %rdi
callq 0x10c0
movq %rax, %r14
movq %rax, %rdi
callq 0x1f54
movq %r14, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::RemoveColumn()
void DancingLinksColumn::RemoveColumn() {
  // Remove the column from the column list
  left_ptr_->set_right_ptr(right_ptr_);
  right_ptr_->set_left_ptr(left_ptr_);

  // Find the 1-cells in the column and remove the other 1-cells in those rows
  //  from their respective columns
  for (DancingLinksCell *ptr = dummycell_->down_ptr(); ptr != dummycell_;
       ptr = ptr->down_ptr()) {
    // Found a 1-cell in the column
    // Erase the row by finding its row neighbours and removing their
    //  vertical links
    for (DancingLinksCell *ptr2 = ptr->right_ptr(); ptr2 != ptr;
         ptr2 = ptr2->right_ptr()) {
      // 1-cell in the row
      // Remove vertical links
      ptr2->RemoveCell();
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%rdi), %rax
movq %rax, %r15
movq 0x18(%r15), %r15
movq %r15, %r14
cmpq %rax, %r15
je 0x204c
movq 0x8(%r14), %r14
cmpq %r15, %r14
je 0x2046
movq %r14, %rdi
callq 0x1f68
jmp 0x2033
movq 0x10(%rbx), %rax
jmp 0x2027
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::UnremoveColumn()
void DancingLinksColumn::UnremoveColumn() {
  // Put back the cells in the reverse order as they were removed
  for (DancingLinksCell *ptr = dummycell_->up_ptr(); ptr != dummycell_;
       ptr = ptr->up_ptr()) {
    for (DancingLinksCell *ptr2 = ptr->left_ptr(); ptr2 != ptr;
         ptr2 = ptr2->left_ptr()) {
      ptr2->UnremoveCell();
    }
  }

  // Insert the column to the column list
  left_ptr_->set_right_ptr(this);
  right_ptr_->set_left_ptr(this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq %rax, %r15
movq 0x10(%r15), %r15
movq %r15, %r14
cmpq %rax, %r15
je 0x2085
movq (%r14), %r14
cmpq %r15, %r14
je 0x207f
movq %r14, %rdi
callq 0x1f80
jmp 0x206d
movq 0x10(%rbx), %rax
jmp 0x2061
movq (%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/train.c
// Function: main
int main(int argc, char **argv)
{
	char input_file_name[1024];
	char model_file_name[1024];
	const char *error_msg;

	parse_command_line(argc, argv, input_file_name, model_file_name);
	read_problem(input_file_name);
	param.train_file = Malloc(char,1024);
	strcpy(param.train_file, input_file_name);
	error_msg = check_parameter(&prob,&param);

	if(error_msg)
	{
		fprintf(stderr,"ERROR: %s\n",error_msg);
		exit(1);
	}

	if(flag_cross_validation)
	{
		do_cross_validation();
	}
	else
	{
		clock_t start_cpu, end_cpu;
		double cpu_time_used;
     	start_cpu = clock();
		model_=train(&prob, &param);
		end_cpu = clock();
     	cpu_time_used = ((double) (end_cpu - start_cpu)) / CLOCKS_PER_SEC;
		if(save_model(model_file_name, model_))
		{
			fprintf(stderr,"can't save model to file %s\n",model_file_name);
			exit(1);
		}
		free_and_destroy_model(&model_);
	}
	destroy_param(&param);
	free(prob.y);
	free(prob.x);
	free(x_space);
	free(line);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
leaq 0x400(%rsp), %rbx
movq %rsp, %rcx
movq %rbx, %rdx
callq 0x374a
movq %rbx, %rdi
callq 0x3cd5
movl $0x400, %edi            # imm = 0x400
callq 0x3320
movq %rax, 0x16c6d(%rip)     # 0x1a2b8
leaq 0x16c2e(%rip), %r14     # 0x1a280
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3200
leaq 0x16cd4(%rip), %rdi     # 0x1a338
movq %r14, %rsi
callq 0x12229
testq %rax, %rax
jne 0x3711
cmpl $0x0, 0x16ce4(%rip)     # 0x1a360
je 0x3685
callq 0x4084
jmp 0x36c8
callq 0x3140
leaq 0x16ca7(%rip), %rdi     # 0x1a338
leaq 0x16be8(%rip), %rsi     # 0x1a280
callq 0x7297
movq %rax, 0x16cb4(%rip)     # 0x1a358
callq 0x3140
movq 0x16ca8(%rip), %rsi     # 0x1a358
movq %rsp, %rdi
callq 0x1195c
testl %eax, %eax
jne 0x3727
leaq 0x16c95(%rip), %rdi     # 0x1a358
callq 0x1172c
leaq 0x16bb1(%rip), %rdi     # 0x1a280
callq 0x1220c
movq 0x16c65(%rip), %rdi     # 0x1a340
callq 0x32b0
movq 0x16c61(%rip), %rdi     # 0x1a348
callq 0x32b0
movq 0x16c3d(%rip), %rdi     # 0x1a330
callq 0x32b0
movq 0x16c71(%rip), %rdi     # 0x1a370
callq 0x32b0
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
movq 0x168c0(%rip), %rcx     # 0x19fd8
movq (%rcx), %rdi
leaq 0x11a55(%rip), %rsi     # 0x15177
movq %rax, %rdx
jmp 0x373b
movq 0x168aa(%rip), %rax     # 0x19fd8
movq (%rax), %rdi
leaq 0x11a4a(%rip), %rsi     # 0x15182
movq %rsp, %rdx
xorl %eax, %eax
callq 0x3370
pushq $0x1
popq %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/train.c
// Function: readline(_IO_FILE*, int)
static char* readline(FILE *input, int max_idx) 
{
	int len;
	
	if(fgets(line,max_line_len,input) == NULL)
		return NULL;

	while(strrchr(line,'\n') == NULL)
	{
		max_line_len *= 2;
		line = (char *) realloc(line,max_line_len);
		len = (int) strlen(line);
		if(fgets(line+len,max_line_len-len,input) == NULL)
			break;
	}

	if(max_idx>0 && (param.structured_w=='s' || param.structured_w=='a' || param.structured_w=='f')) 
	{
		int y;
		double * read_line = (double*) malloc(sizeof(double)*(max_idx+1));
		memset(read_line, 0, sizeof(double)*(max_idx+1));
		split(line, read_line, &y);
		transform_line(read_line,y,max_idx,line, param.structured_w,param.transform_matrix,param.tmx_r,param.tmx_c);
		free(read_line);
	}
	
	return line;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x15f65(%rip), %rdi     # 0x1a370
movl 0x15f67(%rip), %esi     # 0x1a378
movq %r14, %rdx
callq 0x33d0
testq %rax, %rax
je 0x4517
pushq $0xa
popq %rbp
movq 0x15f44(%rip), %r15     # 0x1a370
movq %r15, %rdi
movl %ebp, %esi
callq 0x3270
testq %rax, %rax
jne 0x4484
movslq 0x15f36(%rip), %r12     # 0x1a378
addq %r12, %r12
movl %r12d, 0x15f2c(%rip)    # 0x1a378
movq %r15, %rdi
movq %r12, %rsi
callq 0x3410
movq %rax, %r15
movq %rax, 0x15f0f(%rip)     # 0x1a370
movq %rax, %rdi
callq 0x30f0
cltq
addq %rax, %r15
subl %eax, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x33d0
testq %rax, %rax
jne 0x4425
testl %ebx, %ebx
jle 0x450e
movzbl 0x15e59(%rip), %eax     # 0x1a2ec
addl $-0x61, %eax
cmpl $0x12, %eax
ja 0x450e
movl $0x40021, %ecx          # imm = 0x40021
btl %eax, %ecx
jae 0x450e
movl %ebx, %eax
leaq 0x8(,%rax,8), %rsi
pushq $0x1
popq %rdi
callq 0x3130
movq %rax, %r14
movq 0x15eaf(%rip), %rdi     # 0x1a370
leaq 0xc(%rsp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x13c82
movl (%r15), %esi
movq 0x15e95(%rip), %rcx     # 0x1a370
movsbl 0x15e09(%rip), %r8d     # 0x1a2ec
movq 0x15e06(%rip), %r9      # 0x1a2f0
movl 0x15e08(%rip), %eax     # 0x1a2f8
movl 0x15e05(%rip), %r10d    # 0x1a2fc
movq %r14, %rdi
movl %ebx, %edx
pushq %r10
pushq %rax
callq 0x13dd2
popq %rax
popq %rcx
movq %r14, %rdi
callq 0x32b0
movq 0x15e5b(%rip), %rax     # 0x1a370
jmp 0x4519
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/train.c
// Function: endofline(_IO_FILE*)
int endofline(FILE *ifp)
{
	int c = fgetc(ifp);
	int d = c;
    int eol = (c == '\r' || c == '\n');
    if (c == '\r')
    {
        c = getc(ifp);
        if (c != '\n' && c != EOF)
            ungetc(c, ifp);
    }
    return(eol);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x33c0
movl %eax, %ebx
cmpl $0xd, %eax
jne 0x4555
movq %r14, %rdi
callq 0x30c0
cmpl $-0x1, %eax
je 0x4555
cmpl $0xa, %eax
je 0x4555
movl %eax, %edi
movq %r14, %rsi
callq 0x3080
cmpl $0xd, %ebx
sete %al
cmpl $0xa, %ebx
sete %cl
orb %al, %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::TRON(function const*, double, int)
TRON::TRON(const function *fun_obj, double eps, int max_iter)
{
	this->fun_obj=const_cast<function *>(fun_obj);
	this->eps=eps;
	this->max_iter=max_iter;
	tron_print_string = default_print;
}

// Assembly:
movq %rsi, 0x10(%rdi)
movsd %xmm0, (%rdi)
movl %edx, 0x8(%rdi)
leaq 0x5(%rip), %rax         # 0x47cd
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::norm_inf(int, double*)
double TRON::norm_inf(int n, double *x)
{
	double dmax = fabs(x[0]);
	for (int i=1; i<n; i++)
		if (fabs(x[i]) >= dmax)
			dmax = fabs(x[i]);
	return(dmax);
}

// Assembly:
movsd (%rdx), %xmm0
andpd 0x10d8e(%rip), %xmm0    # 0x16120
movslq %esi, %rax
pushq $0x1
popq %rcx
movapd 0x10d80(%rip), %xmm1    # 0x16120
cmpq %rax, %rcx
jge 0x53cc
movsd (%rdx,%rcx,8), %xmm2
andpd %xmm1, %xmm2
movapd %xmm0, %xmm3
cmplesd %xmm2, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm3
orpd %xmm2, %xmm3
incq %rcx
movapd %xmm3, %xmm0
jmp 0x53a0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::l2r_lr_fun(problem const*, double*)
l2r_lr_fun::l2r_lr_fun(const problem *prob, double *C)
{
	int l=prob->l;

	this->prob = prob;

	z = new double[l];
	D = new double[l];
	this->C = C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x146fa(%rip), %rax     # 0x19ae0
movq %rax, (%rdi)
movslq (%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq %rsi, 0x20(%rdi)
pushq $-0x1
popq %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, 0x10(%r14)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x18(%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::fun(double*)
double l2r_lr_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2.0;
	for(i=0;i<l;i++)
	{
		double yz = y[i]*z[i];
		if (yz >= 0)
			f += C[i]*log(1 + exp(-yz));
		else
			f += C[i]*(-yz+log(1 + exp(yz)));
	}

	return(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %r12
movl (%rcx), %r13d
callq *0x18(%rax)
movl %eax, %r15d
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x557a
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
cmpq %rax, %r15
je 0x54c5
movsd (%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x54ad
mulsd 0x10c33(%rip), %xmm0    # 0x16100
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
cmpq %r14, %r13
je 0x556c
movsd %xmm0, 0x8(%rsp)
movsd (%r12,%r14,8), %xmm1
movq 0x10(%rbx), %rax
mulsd (%rax,%r14,8), %xmm1
movq 0x8(%rbx), %rax
ucomisd 0xfb3e(%rip), %xmm1     # 0x15040
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, (%rsp)
jae 0x5533
movapd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
callq 0x3440
addsd 0x10d72(%rip), %xmm0    # 0x16298
callq 0x31b0
subsd 0x10(%rsp), %xmm0
jmp 0x5551
xorpd 0x10bf5(%rip), %xmm1    # 0x16130
movapd %xmm1, %xmm0
callq 0x3440
addsd 0x10d4c(%rip), %xmm0    # 0x16298
callq 0x31b0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
jmp 0x54d7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Xv(double*, double*)
void l2r_lr_fun::Xv(double *v, double *Xv)
{
	int i;
	int l=prob->l;
	feature_node **x=prob->x;

	for(i=0;i<l;i++)
	{
		feature_node *s=x[i];
		Xv[i]=0;
		while(s->index!=-1)
		{
			Xv[i]+=v[s->index-1]*s->value;
			s++;
		}
	}
}

// Assembly:
movq 0x20(%rdi), %rcx
movl (%rcx), %eax
movq 0x10(%rcx), %rcx
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
cmpq %rax, %rdi
je 0x55c7
movq (%rcx,%rdi,8), %r8
andq $0x0, (%rdx,%rdi,8)
xorpd %xmm0, %xmm0
movslq (%r8), %r9
cmpq $-0x1, %r9
je 0x55c2
movsd -0x8(%rsi,%r9,8), %xmm1
mulsd 0x8(%r8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rdi,8)
addq $0x10, %r8
jmp 0x559d
incq %rdi
jmp 0x558b
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::grad(double*, double*)
void l2r_lr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	for(i=0;i<l;i++)
	{
		z[i] = 1/(1 + exp(-y[i]*z[i]));
		D[i] = z[i]*(1-z[i]);
		z[i] = C[i]*(z[i]-1)*y[i];
	}
	XTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + g[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r12
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %r13
movl (%rcx), %ebp
callq *0x18(%rax)
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
movl %eax, %r15d
cmpq %r14, %rbp
je 0x5685
movsd (%r13,%r14,8), %xmm0
xorpd 0x10b1f(%rip), %xmm0    # 0x16130
movq 0x10(%r12), %rax
mulsd (%rax,%r14,8), %xmm0
callq 0x3440
movsd 0x10c6f(%rip), %xmm2    # 0x16298
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
movq 0x10(%r12), %rax
movsd %xmm1, (%rax,%r14,8)
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movq 0x18(%r12), %rcx
movsd %xmm0, (%rcx,%r14,8)
movq 0x8(%r12), %rcx
movsd (%rax,%r14,8), %xmm0
addsd 0x10c36(%rip), %xmm0    # 0x162a0
mulsd (%rcx,%r14,8), %xmm0
mulsd (%r13,%r14,8), %xmm0
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x55f9
movq 0x10(%r12), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x56ca
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
movq (%rsp), %rcx
cmpq %rax, %r15
je 0x56bb
movsd (%rcx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x56a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::XTv(double*, double*)
void l2r_lr_fun::XTv(double *v, double *XTv)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<l;i++)
	{
		feature_node *s=x[i];
		while(s->index!=-1)
		{
			XTv[s->index-1]+=v[i]*s->value;
			s++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movl (%rcx), %r12d
callq *0x18(%rax)
movq 0x20(%r15), %rcx
movq 0x10(%rcx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x5706
andq $0x0, (%rbx,%rdx,8)
incq %rdx
jmp 0x56f7
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %r12, %rax
je 0x5743
movq (%rcx,%rax,8), %rdx
movslq (%rdx), %rsi
cmpq $-0x1, %rsi
je 0x573e
movsd (%r14,%rax,8), %xmm0
mulsd 0x8(%rdx), %xmm0
addsd -0x8(%rbx,%rsi,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rsi,8)
addq $0x10, %rdx
jmp 0x5718
incq %rax
jmp 0x570f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Hv(double*, double*)
void l2r_lr_fun::Hv(double *s, double *Hs)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	double *wa = new double[l];

	Xv(s, wa);
	for(i=0;i<l;i++)
		wa[i] = C[i]*D[i]*wa[i];

	XTv(wa, Hs);
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + Hs[i];
	delete[] wa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movslq (%rcx), %rbp
callq *0x18(%rax)
movl %eax, %r15d
leaq (,%rbp,8), %rax
testq %rbp, %rbp
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r12
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x557a
movq 0x8(%r13), %rax
movq 0x18(%r13), %rcx
xorl %edx, %edx
testl %ebp, %ebp
movl $0x0, %esi
cmovgl %ebp, %esi
cmpq %rdx, %rsi
je 0x57d8
movsd (%rax,%rdx,8), %xmm0
mulsd (%rcx,%rdx,8), %xmm0
mulsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%r12,%rdx,8)
incq %rdx
jmp 0x57b8
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x56ca
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x5809
movsd (%r14,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x57ef
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::l2r_l2_svc_fun(problem const*, double*)
l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, double *C)
{
	int l=prob->l;

	this->prob = prob;

	z = new double[l];
	D = new double[l];
	I = new int[l];
	this->C = C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x142eb(%rip), %rax     # 0x19b20
movq %rax, (%rdi)
movslq (%rsi), %rax
movq %rsi, 0x30(%rdi)
leaq (,%rax,8), %r15
testq %rax, %rax
pushq $-0x1
popq %rcx
cmovsq %rcx, %r15
leaq (,%rax,4), %r12
cmovsq %rcx, %r12
movq %r15, %rdi
callq 0x3030
movq %rax, 0x10(%r14)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x18(%r14)
movq %r12, %rdi
callq 0x3030
movq %rax, 0x20(%r14)
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::fun(double*)
double l2r_l2_svc_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2.0;
	for(i=0;i<l;i++)
	{
		z[i] = y[i]*z[i];
		double d = 1-z[i];
		if (d > 0)
			f += C[i]*d*d;
	}

	return(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r12
movl (%rcx), %r13d
callq *0x18(%rax)
movl %eax, %r15d
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5968
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
cmpq %rax, %r15
je 0x58ff
movsd (%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x58e7
mulsd 0x107f9(%rip), %xmm0    # 0x16100
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
xorl %edx, %edx
testl %r13d, %r13d
cmovlel %edx, %r13d
movsd 0x10978(%rip), %xmm1    # 0x16298
xorpd %xmm2, %xmm2
cmpq %rdx, %r13
je 0x595d
movsd (%r12,%rdx,8), %xmm4
mulsd (%rcx,%rdx,8), %xmm4
movsd %xmm4, (%rcx,%rdx,8)
movapd %xmm1, %xmm3
subsd %xmm4, %xmm3
ucomisd %xmm2, %xmm3
jbe 0x5958
movsd (%rax,%rdx,8), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rdx
jmp 0x5924
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::grad(double*, double*)
void l2r_l2_svc_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	sizeI = 0;
	for (i=0;i<l;i++)
		if (z[i] < 1)
		{
			z[sizeI] = C[i]*y[i]*(z[i]-1);
			I[sizeI] = i;
			sizeI++;
		}
	subXTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 2*g[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r13
movl (%rcx), %ebp
callq *0x18(%rax)
andl $0x0, 0x28(%r12)
movl %eax, %r15d
movq 0x8(%r12), %rax
movq 0x10(%r12), %rsi
xorl %edx, %edx
testl %ebp, %ebp
cmovlel %edx, %ebp
movq 0x20(%r12), %rcx
movsd 0x10897(%rip), %xmm0    # 0x16298
movsd 0x10897(%rip), %xmm1    # 0x162a0
xorl %edi, %edi
cmpq %rdi, %rbp
je 0x5a4b
movsd (%rsi,%rdi,8), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x5a46
movsd (%rax,%rdi,8), %xmm3
mulsd (%r13,%rdi,8), %xmm3
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm2
movslq %edx, %rdx
movsd %xmm2, (%rsi,%rdx,8)
movl %edi, (%rcx,%rdx,4)
movl 0x28(%r12), %edx
incl %edx
movl %edx, 0x28(%r12)
incq %rdi
jmp 0x5a0b
movq %r12, %rdi
movq %rbx, %rdx
callq 0x5a8c
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x5a7d
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x5a5f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::subXTv(double*, double*)
void l2r_l2_svc_fun::subXTv(double *v, double *XTv)
{
	int i;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<sizeI;i++)
	{
		feature_node *s=x[I[i]];
		while(s->index!=-1)
		{
			XTv[s->index-1]+=v[i]*s->value;
			s++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%r15), %rcx
movq 0x10(%rcx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x5abe
andq $0x0, (%rbx,%rdx,8)
incq %rdx
jmp 0x5aaf
movl 0x28(%r15), %eax
movq 0x20(%r15), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rax, %rsi
je 0x5b07
movslq (%rdx,%rsi,4), %rdi
movq (%rcx,%rdi,8), %rdi
movslq (%rdi), %r8
cmpq $-0x1, %r8
je 0x5b02
movsd (%r14,%rsi,8), %xmm0
mulsd 0x8(%rdi), %xmm0
addsd -0x8(%rbx,%r8,8), %xmm0
movsd %xmm0, -0x8(%rbx,%r8,8)
addq $0x10, %rdi
jmp 0x5ada
incq %rsi
jmp 0x5acd
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::Hv(double*, double*)
void l2r_l2_svc_fun::Hv(double *s, double *Hs)
{
	int i;
	int w_size=get_nr_variable();
	double *wa = new double[sizeI];

	subXv(s, wa);
	for(i=0;i<sizeI;i++)
		wa[i] = C[I[i]]*wa[i];

	subXTv(wa, Hs);
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + 2*Hs[i];
	delete[] wa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %r15d
movslq 0x28(%r13), %rbp
leaq (,%rbp,8), %rax
testq %rbp, %rbp
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r12
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5bde
movq 0x8(%r13), %rax
movq 0x20(%r13), %rcx
xorl %edx, %edx
testl %ebp, %ebp
movl $0x0, %esi
cmovgl %ebp, %esi
cmpq %rdx, %rsi
je 0x5b92
movslq (%rcx,%rdx,4), %rdi
movsd (%rax,%rdi,8), %xmm0
mulsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%r12,%rdx,8)
incq %rdx
jmp 0x5b73
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5a8c
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x5bc7
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x5ba9
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svc_fun::subXv(double*, double*)
void l2r_l2_svc_fun::subXv(double *v, double *Xv)
{
	int i;
	feature_node **x=prob->x;

	for(i=0;i<sizeI;i++)
	{
		feature_node *s=x[I[i]];
		Xv[i]=0;
		while(s->index!=-1)
		{
			Xv[i]+=v[s->index-1]*s->value;
			s++;
		}
	}
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x10(%rcx), %rcx
movslq 0x28(%rdi), %rdi
xorl %r8d, %r8d
cmpq %rdi, %r8
jge 0x5c32
movslq (%rax,%r8,4), %r9
movq (%rcx,%r9,8), %r9
andq $0x0, (%rdx,%r8,8)
xorpd %xmm0, %xmm0
movslq (%r9), %r10
cmpq $-0x1, %r10
je 0x5c2d
movsd -0x8(%rsi,%r10,8), %xmm1
mulsd 0x8(%r9), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r8,8)
addq $0x10, %r9
jmp 0x5c07
incq %r8
jmp 0x5bf1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svr_fun::fun(double*)
double l2r_l2_svr_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();
	double d;
	
	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2;	
	for(i=0;i<l;i++)
	{
		d = z[i] - y[i];
		if(d < -p)
			f += C[i]*(d+p)*(d+p);
		else if(d > p)
			f += C[i]*(d-p)*(d-p);
	}

	return(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r12
movl (%rcx), %r13d
callq *0x18(%rax)
movl %eax, %r15d
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5968
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
cmpq %rax, %r15
je 0x5cb9
movsd (%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x5ca1
mulsd 0x1043f(%rip), %xmm0    # 0x16100
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd 0x38(%rbx), %xmm1
movapd 0x1045a(%rip), %xmm2    # 0x16130
xorpd %xmm1, %xmm2
xorl %edx, %edx
testl %r13d, %r13d
cmovlel %edx, %r13d
cmpq %rdx, %r13
je 0x5d1f
movsd (%rcx,%rdx,8), %xmm3
subsd (%r12,%rdx,8), %xmm3
ucomisd %xmm3, %xmm2
jbe 0x5cff
addsd %xmm1, %xmm3
jmp 0x5d09
ucomisd %xmm1, %xmm3
jbe 0x5d1a
subsd %xmm1, %xmm3
movsd (%rax,%rdx,8), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rdx
jmp 0x5ce3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_l2_svr_fun::grad(double*, double*)
void l2r_l2_svr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();
	double d;

	sizeI = 0;
	for(i=0;i<l;i++)
	{
		d = z[i] - y[i];
		
		// generate index set I
		if(d < -p)
		{
			z[sizeI] = C[i]*(d+p);
			I[sizeI] = i;
			sizeI++;
		}
		else if(d > p)
		{
			z[sizeI] = C[i]*(d-p);
			I[sizeI] = i;
			sizeI++;
		}
	
	}
	subXTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 2*g[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rcx), %r13
movl (%rcx), %ebp
callq *0x18(%rax)
movl %eax, %r15d
andl $0x0, 0x28(%r12)
movq 0x8(%r12), %rax
movq 0x10(%r12), %rsi
movq 0x20(%r12), %rcx
xorl %edx, %edx
testl %ebp, %ebp
cmovlel %edx, %ebp
movapd 0x103bb(%rip), %xmm0    # 0x16130
xorl %edi, %edi
cmpq %rdi, %rbp
je 0x5dce
movsd (%rsi,%rdi,8), %xmm1
subsd (%r13,%rdi,8), %xmm1
movsd 0x38(%r12), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x5da3
addsd %xmm2, %xmm1
jmp 0x5dad
ucomisd %xmm2, %xmm1
jbe 0x5dc9
subsd %xmm2, %xmm1
mulsd (%rax,%rdi,8), %xmm1
movslq %edx, %rdx
movsd %xmm1, (%rsi,%rdx,8)
movl %edi, (%rcx,%rdx,4)
movl 0x28(%r12), %edx
incl %edx
movl %edx, 0x28(%r12)
incq %rdi
jmp 0x5d77
movq %r12, %rdi
movq %rbx, %rdx
callq 0x5a8c
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x5e00
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x5de2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: free_and_destroy_model
void free_and_destroy_model(struct model **model_ptr_ptr)
{
	struct model *model_ptr = *model_ptr_ptr;
	if(model_ptr != NULL)
	{
		free_model_content(model_ptr);
		free(model_ptr);
	}
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x11746
movq %rbx, %rdi
callq 0x121ef
movq %rbx, %rdi
popq %rbx
jmp 0x32b0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: predict_values
double predict_values(const struct model *model_, const struct feature_node *x, double *dec_values)
{
	int idx;
	int n;
	if(model_->bias>=0)
		n=model_->nr_feature+1;
	else
		n=model_->nr_feature;
	double *w=model_->w;
	int nr_class=model_->nr_class;
	int i;
	int nr_w;
	if(nr_class==2 && model_->param.solver_type != MCSVM_CS)
		nr_w = 1;
	else
		nr_w = nr_class;

	const feature_node *lx=x;
	for(i=0;i<nr_w;i++)
		dec_values[i] = 0;
	for(; (idx=lx->index)!=-1; lx++)
	{
		// the dimension of testing data may exceed that of training
		if(idx<=n)
			for(i=0;i<nr_w;i++)
				dec_values[i] += w[(idx-1)*nr_w+i]*lx->value;
	}

	if(nr_class==2)
	{
		if(model_->param.solver_type == L2R_L2LOSS_SVR ||
		   model_->param.solver_type == L2R_L1LOSS_SVR_DUAL ||
		   model_->param.solver_type == L2R_L2LOSS_SVR_DUAL)
			return dec_values[0];
		else
			return (dec_values[0]>0)?model_->label[0]:model_->label[1];
	}
	else
	{
		int dec_max_idx = 0;
		for(i=1;i<nr_class;i++)
		{
			if(dec_values[i] > dec_values[dec_max_idx])
				dec_max_idx = i;
		}
		return model_->label[dec_max_idx];
	}
}

// Assembly:
movsd 0xc8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0xb4(%rdi), %ecx
sbbl $-0x1, %ecx
movslq 0xb0(%rdi), %rax
cmpq $0x2, %rax
jne 0x11773
cmpl $0x4, (%rdi)
jne 0x11778
movl %eax, %r8d
jmp 0x1177e
movl $0x1, %r8d
movq 0xb8(%rdi), %r9
xorl %r11d, %r11d
testl %r8d, %r8d
movl $0x0, %r10d
cmovgl %r8d, %r10d
cmpq %r11, %r10
je 0x117a4
andq $0x0, (%rdx,%r11,8)
incq %r11
jmp 0x11795
pushq %rbx
movl (%rsi), %r11d
cmpl $-0x1, %r11d
je 0x117e8
cmpl %ecx, %r11d
jle 0x117b9
addq $0x10, %rsi
jmp 0x117a5
decl %r11d
imull %r8d, %r11d
movslq %r11d, %r11
leaq (%r9,%r11,8), %r11
xorl %ebx, %ebx
cmpq %rbx, %r10
je 0x117b3
movsd (%r11,%rbx,8), %xmm0
mulsd 0x8(%rsi), %xmm0
addsd (%rdx,%rbx,8), %xmm0
movsd %xmm0, (%rdx,%rbx,8)
incq %rbx
jmp 0x117c9
cmpl $0x2, %eax
jne 0x1180e
movl (%rdi), %eax
addl $-0xb, %eax
movsd (%rdx), %xmm0
cmpl $0x3, %eax
jb 0x1184b
xorpd %xmm1, %xmm1
xorl %esi, %esi
ucomisd %xmm1, %xmm0
setbe %sil
shll $0x2, %esi
jmp 0x11840
xorl %r8d, %r8d
movabsq $0x1, %rcx
movslq %r8d, %rsi
cmpq %rax, %rcx
jge 0x1183c
movsd (%rdx,%rcx,8), %xmm0
ucomisd (%rdx,%rsi,8), %xmm0
movl %ecx, %esi
ja 0x11834
movl %r8d, %esi
incq %rcx
movl %esi, %r8d
jmp 0x1181b
shlq $0x2, %rsi
addq 0xc0(%rdi), %rsi
cvtsi2sdl (%rsi), %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: free_model_content
void free_model_content(struct model *model_ptr)
{
	if(model_ptr->w != NULL)
		free(model_ptr->w);
	if(model_ptr->label != NULL)
		free(model_ptr->label);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
callq 0x32b0
movq 0xc0(%rbx), %rdi
popq %rbx
jmp 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: destroy_param
void destroy_param(parameter* param)
{
	if(param->weight_label != NULL)
		free(param->weight_label);
	if(param->weight != NULL)
		free(param->weight);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
callq 0x32b0
movq 0xa0(%rbx), %rdi
popq %rbx
jmp 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/linear.cpp
// Function: shrink(double, double)
static double shrink(double w, double gamma) {
	if (w < gamma && w > -gamma)
		return 0;
	else if (w < 0)
		return w+gamma;
	else if (w > 0)
		return w-gamma;
	return 0;
}

// Assembly:
ucomisd %xmm0, %xmm1
jbe 0x131ed
movapd 0x2f51(%rip), %xmm3     # 0x16130
xorpd %xmm1, %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm3, %xmm0
ja 0x1320b
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x131fd
addsd %xmm1, %xmm0
jmp 0x13207
ucomisd %xmm2, %xmm0
jbe 0x1320b
subsd %xmm1, %xmm0
movapd %xmm0, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/transform_line.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char)
unsigned int split(const std::string &txt, std::vector<std::string> &strs, char ch)
{
    size_t pos = txt.find( ch );
    size_t initialPos = 0;
    strs.clear();

    // Decompose statement
    while( pos != std::string::npos ) {
        strs.push_back( txt.substr( initialPos, pos - initialPos + 1 ) );
        initialPos = pos + 1;

        pos = txt.find( ch, initialPos );
    }

    // Add the last one
    strs.push_back( txt.substr( initialPos, std::min( pos, txt.size() ) - initialPos + 1 ) );

    return strs.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movl %edx, %esi
xorl %edx, %edx
callq 0x3310
movq %rax, %rbx
movq %r15, (%rsp)
movq %r15, %rdi
callq 0x14084
leaq 0x8(%rsp), %r15
movsbl %bpl, %ebp
cmpq $-0x1, %rbx
je 0x13c1b
movq %rbx, %r13
incq %r13
movq %r13, %rcx
subq %r12, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3260
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x141d6
movq %r15, %rdi
callq 0x3100
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x3310
movq %rax, %rbx
movq %r13, %r12
jmp 0x13bd2
movq 0x8(%r14), %rcx
subq %r12, %rcx
incq %rcx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3260
movq (%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x141d6
leaq 0x8(%rsp), %rdi
callq 0x3100
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x5, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13c6d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/qmmlib[P]QmmLibrary/transform_line.cpp
// Function: split
void split(char* _str, double* read_line, int * y)
{
    int i = 0;
	while(1)
	{
		if(_str[i]==0)
			break;
		else if(_str[i]==':' || _str[i]=='\r' || _str[i]=='\n' || _str[i]=='\t')
			_str[i] = ' ';
		i++;
	}
	
	std::vector<std::string> v;
	std::string str(_str);
	split(str, v, ' ' ); 
	
	bool labeled = false;
	int last_index = 0;
	for(int i=0; i<v.size(); i++)
	{
		string s = v[i];
		if(s.find_first_not_of(' ') != std::string::npos)
		{
			if(!labeled)
			{
				*y = atoi(s.c_str());
				labeled = true;
				continue;
			}
			if(last_index==0)
				last_index = (int) atof(s.c_str());
			else
			{
				read_line[last_index] = atof(s.c_str());
				last_index = 0;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rsi
movabsq $0x400000000002600, %rax # imm = 0x400000000002600
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpq $0x3a, %rdx
ja 0x13cbc
btq %rdx, %rax
jae 0x13cc1
movb $0x20, (%rcx)
incq %rcx
jmp 0x13caa
testq %rdx, %rdx
jne 0x13cbc
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1408c
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
pushq $0x20
popq %rdx
callq 0x13b98
xorl %r12d, %r12d
leaq 0x28(%rsp), %r15
pushq $0x20
popq %rbp
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %r14d, %r14d
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x13d8d
addq %r12, %rsi
movq %r15, %rdi
callq 0x3330
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x31f0
cmpq $-0x1, %rax
je 0x13d79
testb $0x1, %bl
je 0x13d54
movq 0x28(%rsp), %rdi
callq 0x32d0
testl %r14d, %r14d
jne 0x13d67
cvttsd2si %xmm0, %r14d
jmp 0x13d77
movq 0x28(%rsp), %rdi
callq 0x33a0
movq 0x20(%rsp), %rcx
movl %eax, (%rcx)
jmp 0x13d77
movslq %r14d, %rax
movq 0x18(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
xorl %r14d, %r14d
movb $0x1, %bl
movq %r15, %rdi
callq 0x3100
incq %r13
addq $0x20, %r12
jmp 0x13d07
leaq 0x48(%rsp), %rdi
callq 0x3100
movq %rsp, %rdi
callq 0x140c8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13db5
movq %rax, %rbx
jmp 0x13dc2
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3100
movq %rsp, %rdi
callq 0x140c8
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/CHEN-Zhihan[P]Compiler/compiler.cpp
// Function: defineFunctions()
void defineFunctions() {
    for (const auto& FID : functionLabel) {
        auto func = functionTable[FID.first];
        int tempVariablesSize = addressTable[FID.first].first;
        printf("L%03d:\n", FID.second);
        if (tempVariablesSize != 0) {
            printf("\tpush\t%d\n", tempVariablesSize);
            printf("\tpush\tsp\n");   
            printf("\tadd\n");
            printf("\tpop\tsp\n");
        }
        auto v = vector<int>{FID.first};
        func->exStmt(v, FID.first, 998, 998);
        printf("\tpush\t0\n");
        printf("\tret\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x14b18(%rip), %r13     # 0x1d408
leaq -0x48(%rbp), %r12
movq (%r13), %r13
testq %r13, %r13
je 0x89ca
leaq 0x8(%r13), %rbx
leaq 0x14a44(%rip), %rdi     # 0x1d350
movq %rbx, %rsi
callq 0x9a14
movq (%rax), %r14
leaq 0x14b4a(%rip), %rdi     # 0x1d468
movq %rbx, %rsi
callq 0x9d9e
movl (%rax), %r15d
movl 0xc(%r13), %esi
leaq 0xacc6(%rip), %rdi      # 0x135fa
xorl %eax, %eax
callq 0x3040
testl %r15d, %r15d
je 0x8975
leaq 0xacbb(%rip), %rdi      # 0x13602
movl %r15d, %esi
xorl %eax, %eax
callq 0x3040
leaq 0xacf7(%rip), %rdi      # 0x1364f
callq 0x3310
leaq 0xacf4(%rip), %rdi      # 0x13658
callq 0x3310
leaq 0xaced(%rip), %rdi      # 0x1365d
callq 0x3310
movl (%rbx), %eax
movl %eax, -0x30(%rbp)
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
pushq $0x1
popq %rdx
leaq -0x29(%rbp), %rcx
callq 0x8fa8
movl (%rbx), %edx
movq %r14, %rdi
movq %r12, %rsi
movl $0x3e6, %ecx            # imm = 0x3E6
movl $0x3e6, %r8d            # imm = 0x3E6
callq 0xceba
leaq 0xac96(%rip), %rdi      # 0x13642
callq 0x3310
leaq 0xac92(%rip), %rdi      # 0x1364a
callq 0x3310
movq %r12, %rdi
callq 0xa21e
jmp 0x88f4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa21e
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: findSpace(int, int)
int findSpace(int functionID, int targetSize) {
    for (const auto & i : reusableAddress[functionID]) {
        if (i.second == targetSize) {
            #if DEBUG
                cerr << "found a space at " << i.first << " of size " << targetSize << endl;
            #endif
            reusableAddress[functionID].erase(i);
            return i.first;
        } else if (i.second > targetSize) {
            #if DEBUG
                cerr << "found a space at " << i.first << " of size " << i.second << " " << i.second - targetSize << " left" << endl;
            #endif
            reusableAddress[functionID].erase(i);
            reusableAddress[functionID].insert({i.first + targetSize, i.second - targetSize});
            return i.first;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
leaq 0x1208b(%rip), %rdi     # 0x1d430
callq 0xaf76
movq %rax, %r12
movq 0x18(%rax), %rbx
addq $0x8, %r12
pushq $-0x1
popq %r15
cmpq %r12, %rbx
je 0xb44b
cmpl %r14d, 0x24(%rbx)
je 0xb3d7
jg 0xb3f8
movq %rbx, %rdi
callq 0x3230
movq %rax, %rbx
jmp 0xb3b9
addq $0x20, %rbx
leaq 0x1204e(%rip), %rdi     # 0x1d430
leaq -0x2c(%rbp), %rsi
callq 0xaf76
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf588
jmp 0xb448
leaq 0x20(%rbx), %r15
leaq 0x1202d(%rip), %r12     # 0x1d430
leaq -0x2c(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xaf76
movq %rax, %rdi
movq %r15, %rsi
callq 0xf588
movq %r12, %rdi
movq %r13, %rsi
callq 0xaf76
movl 0x20(%rbx), %ecx
addl %r14d, %ecx
movl 0x24(%rbx), %edx
subl %r14d, %edx
leaq -0x34(%rbp), %rsi
movl %ecx, (%rsi)
movl %edx, 0x4(%rsi)
movq %rax, %rdi
callq 0xf794
movq %r15, %rbx
movl (%rbx), %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: releaseSpace(int, int)
void releaseSpace(int functionID, int scopeID) {
    for (const auto & i : addressTable[functionID].second[scopeID]) {
        auto dimension = sizeMap[{scopeID, i.first}];
        auto size = accumulate(dimension.begin(), dimension.end(), 1, multiplies<int>());
        auto p = pair<int, int>{i.second, size};
        reusableAddress[functionID].insert(p);
        #if DEBUG
            cerr << "Returning space at " << i.second << " of size " << size << endl; 
        #endif
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movl %edi, (%rax)
leaq -0x34(%rbp), %rbx
movl %esi, (%rbx)
leaq 0x11fe7(%rip), %rdi     # 0x1d468
movq %rax, %rsi
callq 0x9d9e
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0xf958
movq %rax, %r14
addq $0x10, %r14
leaq -0x30(%rbp), %r12
leaq -0x50(%rbp), %r13
pushq $0x1
popq %r15
leaq 0x11f81(%rip), %rbx     # 0x1d430
movq (%r14), %r14
testq %r14, %r14
je 0xb522
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl 0x8(%r14), %eax
movl %eax, -0x2c(%rbp)
leaq 0x11fe5(%rip), %rdi     # 0x1d4b0
movq %r12, %rsi
callq 0xeb8a
movq %r13, %rdi
movq %rax, %rsi
callq 0xebf4
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rdx
movl %r15d, %eax
cmpq %rdx, %rcx
je 0xb4f7
imull (%rcx), %eax
addq $0x4, %rcx
jmp 0xb4e9
movl 0xc(%r14), %ecx
movl %ecx, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0xaf76
movq %rax, %rdi
movq %r12, %rsi
callq 0x10074
movq %r13, %rdi
callq 0xa21e
jmp 0xb4af
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa21e
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: incdec(std::shared_ptr<VarNode>, int, int, std::vector<int, std::allocator<int>>&, int, bool)
void incdec(shared_ptr<VarNode> v, int blbl, int clbl, vector<int>& sList, int function, bool inc) {
    v->ex(sList, function, blbl, clbl);
    printf("\tpush\t1\n");
    if (inc) {
        printf("\tadd\n");
    } else {
        printf("\tsub\n");
    }
    v->pop(sList, function);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %r15d
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r8d
movl %esi, %ecx
movq %rdi, %r12
movq (%rdi), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *(%rax)
leaq 0x83d2(%rip), %rdi      # 0x13aff
callq 0x3310
leaq 0x7f1f(%rip), %rax      # 0x13658
leaq 0x83c7(%rip), %rdi      # 0x13b07
testl %r15d, %r15d
cmovneq %rax, %rdi
callq 0x3310
movq (%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb762
// File: /workspace/github_cpp_makefile_star2_O2/CHEN-Zhihan[P]Compiler/Node.cpp
// Function: ExprNode::ExprNode(int, std::vector<std::shared_ptr<Node>, std::allocator<std::shared_ptr<Node>>> const&)
ExprNode::ExprNode(int oper, const vector<shared_ptr<Node> > &op):oper(oper) {
    this->op = array<shared_ptr<Node>, 2>();
    this->op[0] = op[0];
    if (op.size() == 2) {
        this->op[1] = op[1];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1133e(%rip), %rax     # 0x1cac8
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
leaq 0x18(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
leaq -0x40(%rbp), %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0xec4c
movq %r12, %rdi
callq 0xec86
movq (%r14), %rsi
movq %r15, %rdi
callq 0xf390
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0xb7ec
addq $0x10, %rsi
addq $0x28, %rbx
movq %rbx, %rdi
callq 0xf390
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop