LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Shrinker::Execute()
void Shrinker::Execute()
{
	OneInputCheck();
	Pixel *data = inputImg1->GetBuffer();
	int oldWidth = inputImg1->GetWidth();
	int newWidth = oldWidth / 2;
	int newHeight = inputImg1->GetHeight() / 2;
	Pixel *smallerData = new Pixel[ newWidth * newHeight];
	for(int i = 0; i < newHeight; i++)
	{
		for(int j = 0; j < newWidth; j++)
		{
			smallerData[i * newWidth + j] = data[2* i * oldWidth + 2 * j];
		}
	}
	outputImg.ResetSize(newWidth,newHeight);
	outputImg.SetBuffer(smallerData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x3a5c
movq 0x30(%rbx), %rdi
callq 0x398c
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x3978
movl %eax, %r12d
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
movq %rbx, -0x40(%rbp)
movq 0x30(%rbx), %rdi
callq 0x3982
movl %eax, %r13d
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
movl %eax, -0x2c(%rbp)
movl %r15d, -0x30(%rbp)
imull %r15d, %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, -0x38(%rbp)
cmpl $0x2, %r13d
jl 0x44ce
movslq -0x30(%rbp), %rdx
movl -0x2c(%rbp), %eax
movl %edx, %ecx
leaq (%rdx,%rdx,2), %rdx
leal (%r12,%r12), %esi
xorl %edi, %edi
movq -0x38(%rbp), %r8
xorl %r9d, %r9d
movq %rcx, %r10
movl %edi, %r11d
movq %r8, %r13
cmpl $0x2, %r12d
jl 0x44c1
movslq %r11d, %r11
leaq (%r11,%r11,2), %r15
movb 0x2(%r14,%r15), %bl
movb %bl, 0x2(%r13)
movzwl (%r14,%r15), %ebx
movw %bx, (%r13)
addq $0x3, %r13
addl $0x2, %r11d
decq %r10
jne 0x449a
incq %r9
addq %rdx, %r8
addl %esi, %edi
cmpq %rax, %r9
jne 0x448b
movq -0x40(%rbp), %rbx
addq $0x8, %rbx
movq %rbx, %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x39ea
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39f6
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Transpose::Execute()
void Transpose::Execute()
{
	OneInputCheck();
        int oldHeight = inputImg1->GetHeight();
        int oldWidth = inputImg1->GetWidth();
        int newHeight = oldWidth;
        int newWidth = oldHeight;
	Pixel *outBuffer = new Pixel[newHeight * newWidth];
	Pixel *inBuffer1 = inputImg1->GetBuffer();
	for (int h = 0 ; h < oldHeight ; h++){
        	for (int w = 0 ; w < oldWidth ; w++){
			outBuffer[w * oldHeight + h] = inBuffer1[h * oldWidth + w];
                }
        }
        outputImg.ResetSize(newWidth, newHeight);
        outputImg.SetBuffer(outBuffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x3a5c
movq 0x30(%rbx), %rdi
callq 0x3982
movl %eax, %r14d
movq 0x30(%rbx), %rdi
callq 0x3978
movl %eax, %r15d
imull %r14d, %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x398c
testl %r14d, %r14d
jle 0x51ad
movl %r15d, %edx
movl %r14d, %ecx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rcx,2), %rsi
xorl %edi, %edi
movq %r12, %r8
testl %r15d, %r15d
jle 0x519e
movq %r8, %r9
xorl %r10d, %r10d
movb 0x2(%rax,%r10), %r11b
movb %r11b, 0x2(%r9)
movzwl (%rax,%r10), %r11d
movw %r11w, (%r9)
addq $0x3, %r10
addq %rsi, %r9
cmpq %r10, %rdx
jne 0x5180
incq %rdi
addq %rdx, %rax
addq $0x3, %r8
cmpq %rcx, %rdi
jne 0x5175
addq $0x8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x39ea
movq %rbx, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x39f6
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Invert::Execute()
void Invert::Execute()
{
        OneInputCheck();
        int height = inputImg1->GetHeight();
        int width = inputImg1->GetWidth();
        Pixel *outBuffer = new Pixel[height * width];
        Pixel *inBuffer1 = inputImg1->GetBuffer();
        for (int h = 0 ; h < height ; h++){
                for (int w = 0 ; w < width ; w++){
                        outBuffer[h * width + w].red = 255 - inBuffer1[h * width + w].red;
                        outBuffer[h * width + w].green = 255 - inBuffer1[h * width + w].green;
                        outBuffer[h * width + w].blue = 255 - inBuffer1[h * width + w].blue;
                }
        }
        outputImg.ResetSize(width, height);
        outputImg.SetBuffer(outBuffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x3a5c
movq 0x30(%rbx), %rdi
callq 0x3982
movl %eax, %r14d
movq 0x30(%rbx), %rdi
callq 0x3978
movl %eax, %r15d
imull %r14d, %eax
cltq
movl $0x3, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x398c
testl %r14d, %r14d
jle 0x528b
movl %r15d, %esi
movl %r14d, %ecx
movq %r12, %rdx
addq $0x2, %rdx
leaq (%rsi,%rsi,2), %rsi
addq $0x2, %rax
xorl %edi, %edi
testl %r15d, %r15d
jle 0x527d
xorl %r8d, %r8d
movb -0x2(%rax,%r8), %r9b
notb %r9b
movb %r9b, -0x2(%rdx,%r8)
movb -0x1(%rax,%r8), %r9b
notb %r9b
movb %r9b, -0x1(%rdx,%r8)
movb (%rax,%r8), %r9b
notb %r9b
movb %r9b, (%rdx,%r8)
addq $0x3, %r8
cmpq %r8, %rsi
jne 0x524f
incq %rdi
addq %rsi, %rdx
addq %rsi, %rax
cmpq %rcx, %rdi
jne 0x5247
addq $0x8, %rbx
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x39ea
movq %rbx, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x39f6
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Color::Color(int, int, int, int, int)
Color::Color(int w, int h, int r, int g, int b)
{
	red = r;
	green = g;
	blue = b;
	width = w;
	height = h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x320a(%rip), %rax      # 0x8778
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x38c8
leaq 0x3407(%rip), %rax      # 0x8988
movq %rax, (%rbx)
movl %r15d, 0x30(%rbx)
movl %r14d, 0x34(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x38(%rbx)
movl %r13d, 0x28(%rbx)
movl %r12d, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: Color::Execute()
void Color::Execute()
{
	int length = width * height;
	Pixel *data = new Pixel[length];
	for(int i = 0; i < length; i++){
		data[i].red = red;
		data[i].green = green;
		data[i].blue = blue;
	}
	outputImg.ResetSize(width,height);
        outputImg.SetBuffer(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %r14d
movl 0x2c(%rdi), %r15d
movl %r15d, -0x2c(%rbp)
imull %r14d, %r15d
movslq %r15d, %r13
movl $0x3, %ecx
movq %r13, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, %r12
testl %r13d, %r13d
jle 0x561a
movb 0x30(%rbx), %al
movb 0x34(%rbx), %cl
movb 0x38(%rbx), %dl
movl %r15d, %esi
leaq (%rsi,%rsi,2), %rsi
xorl %edi, %edi
movb %al, (%r12,%rdi)
movb %cl, 0x1(%r12,%rdi)
movb %dl, 0x2(%r12,%rdi)
addq $0x3, %rdi
cmpq %rdi, %rsi
jne 0x5603
addq $0x8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
movl -0x2c(%rbp), %edx
callq 0x39ea
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39f6
nop
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/filters.cpp
// Function: CheckSum::OutputCheckSum()
void CheckSum::OutputCheckSum()
{
	unsigned char redSum = 0;
	unsigned char greenSum = 0;
	unsigned char blueSum = 0;
        OneInputCheck();
	int numOfPixels = inputImg1->GetWidth() * inputImg1->GetHeight();
	Pixel *inBuffer1 = inputImg1->GetBuffer();

	for(int i = 0; i < numOfPixels; i++){
		redSum = (unsigned char) (redSum + inBuffer1[i].red);
		greenSum =(unsigned char) (greenSum + inBuffer1[i].green);
		blueSum = (unsigned char) (blueSum + inBuffer1[i].blue);
	}
        FILE *f_out;
        f_out = fopen("log/checksum", "w+");
        if(f_out == NULL){
        	f_out = fopen("../log/checksum", "w+");
        	if(f_out == NULL){
                	fprintf(stderr, "Failure opening output file");
                	exit(EXIT_FAILURE);
		}
        }
        fprintf( f_out, "CHECKSUM: %d, %d, %d\n", redSum, greenSum, blueSum);
        fclose(f_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x3a5c
movq 0x8(%r14), %rdi
callq 0x3978
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x3982
movl %eax, %ebx
imull %r15d, %ebx
movq 0x8(%r14), %rdi
callq 0x398c
testl %ebx, %ebx
jle 0x57d9
movl %ebx, %ecx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %r8d, %r8d
addb (%rax,%rdx), %sil
addb 0x1(%rax,%rdx), %dil
addb 0x2(%rax,%rdx), %r8b
addq $0x3, %rdx
cmpq %rdx, %rcx
jne 0x57b4
movzbl %sil, %r15d
movzbl %dil, %r14d
movzbl %r8b, %ebx
jmp 0x57e1
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
leaq 0xb0c(%rip), %rdi       # 0x62f4
leaq 0x94b(%rip), %rsi       # 0x613a
callq 0x3130
testq %rax, %rax
jne 0x5811
leaq 0xaf1(%rip), %rdi       # 0x62f1
leaq 0x933(%rip), %rsi       # 0x613a
callq 0x3130
testq %rax, %rax
je 0x583e
movq %rax, %r12
leaq 0xae6(%rip), %rsi       # 0x6301
movq %rax, %rdi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x3160
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
callq 0x3240
nop
// File: /workspace/github_cpp_makefile_star2_O1/CodyNault[P]Image-Filter-Dataflow/src/logging.cpp
// Function: Logger::LogEvent(char const*)
void Logger::LogEvent(const char *event)
{
	if(logger == NULL){
		logger = fopen("log/log_file", "w");
        	if(logger == NULL){
			logger = fopen("../log/log_file", "w");
        		if(logger == NULL){
                		DataFlowException except("Logger", "Cannot lock log file!");
                		throw except;
			}
        	}
	}	
        fprintf(logger, "%s\n", event);
//	fprintf(stderr,"%s\n", event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
cmpq $0x0, 0x3649(%rip)      # 0x9168
jne 0x5b5f
leaq 0x8ea(%rip), %rdi       # 0x6412
leaq 0x584(%rip), %rsi       # 0x60b3
callq 0x3130
movq %rax, 0x362d(%rip)      # 0x9168
testq %rax, %rax
jne 0x5b5f
leaq 0x8c8(%rip), %rdi       # 0x640f
leaq 0x565(%rip), %rsi       # 0x60b3
callq 0x3130
movq %rax, 0x360e(%rip)      # 0x9168
testq %rax, %rax
je 0x5b84
movq 0x3602(%rip), %rdi      # 0x9168
leaq 0x8c8(%rip), %rsi       # 0x6435
movq %rbx, %rdx
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3160
leaq 0x2d25(%rip), %r15      # 0x88b0
leaq -0x418(%rbp), %rbx
movq %r15, -0x8(%rbx)
movups 0x882(%rip), %xmm0      # 0x641f
movups %xmm0, (%rbx)
movabsq $0x21656c69662067, %rax # imm = 0x21656C69662067
movq %rax, 0xe(%rbx)
movl $0x408, %edi            # imm = 0x408
callq 0x3090
movq %rax, %r14
movq %r15, (%rax)
leaq 0x8(%rax), %rdi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rsi
callq 0x30b0
leaq 0x2cb2(%rip), %rsi      # 0x8888
movq 0x3403(%rip), %rdx      # 0x8fe0
movq %r14, %rdi
callq 0x31a0
movq %rax, %rbx
leaq -0x420(%rbp), %rdi
callq 0x31e8
movq %rbx, %rdi
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/main.cpp
// Function: printet(etree*, int)
void printet(et *e,int n){
	int s;
	for(int k=0;k<n;k++){
		printf("par[%d] is %d,chl are ",k,e->par[k]);
		s=(int)e->chl->at(k)->size();
		for(int j=0;j<s;j++){
			printf("%d ",e->chl->at(k)->at(j));

		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
testl %esi, %esi
jle 0x13dd
movq %rdi, %r14
leaq -0x2c(%rbp), %r12
leaq 0x1cd5(%rip), %r13      # 0x301f
xorl %eax, %eax
movq (%r14), %rcx
movslq %eax, %rsi
movl (%rcx,%rsi,4), %edx
leaq 0x1cac(%rip), %rdi      # 0x3008
xorl %eax, %eax
callq 0x1030
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x15f8
movq (%rax), %rax
movq 0x8(%rax), %rbx
subq (%rax), %rbx
shrq $0x2, %rbx
testl %ebx, %ebx
jle 0x13c2
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x15f8
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
jbe 0x13ec
movl (%rax,%r15,4), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1030
incq %r15
cmpq %r15, %rbx
jne 0x138a
movl $0xa, %edi
callq 0x1160
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
cmpl -0x30(%rbp), %eax
jl 0x134c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c76(%rip), %rdi      # 0x3069
movq %r15, %rsi
xorl %eax, %eax
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/main.cpp
// Function: print_cs(std::map<int, std::vector<int, std::allocator<int>>*, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>*>>>*)
void print_cs(map<int,vector<int>* > *e){
	int s,n=e->size();
	for(int k=0;k<n;k++){
		printf("col_struct[%d] is  ",k);
		s=(int)e->at(k)->size();
		for(int j=0;j<s;j++){
			printf("%d ",e->at(k)->at(j));

		}
		printf("\n");
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x28(%rdi), %eax
movl $0x0, -0x2c(%rbp)
movl %eax, -0x30(%rbp)
testl %eax, %eax
jle 0x14b8
movq %rdi, %rbx
leaq -0x2c(%rbp), %r15
leaq 0x1bf1(%rip), %r12      # 0x301f
xorl %esi, %esi
leaq 0x1bec(%rip), %rdi      # 0x3023
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15f8
movq (%rax), %rax
movq 0x8(%rax), %r14
subq (%rax), %r14
shrq $0x2, %r14
testl %r14d, %r14d
jle 0x149d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15f8
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r13, %rdx
jbe 0x14c7
movl (%rax,%r13,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1030
incq %r13
cmpq %r13, %r14
jne 0x1466
movl $0xa, %edi
callq 0x1160
movl -0x2c(%rbp), %esi
incl %esi
movl %esi, -0x2c(%rbp)
cmpl -0x30(%rbp), %esi
jl 0x1430
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b9b(%rip), %rdi      # 0x3069
movq %r13, %rsi
xorl %eax, %eax
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/main.cpp
// Function: main
int main(){
	sm *A;
	FILE *f;
	f=fopen("input.txt","r");
	A=load(f);
	fclose(f);
	sm *B=TripletToCC(A);
	int n=B->n;
	printf("given matrix A:\n");

	

	clock_t t = clock();

	et *e=buildTree(B);

	map<int,vector<int>* > * col_strut=col_structure(e,B);

	sm *L=sm_chol(B,e,col_strut);

	printf("\nTime taken: %.4fs\n", (float)(clock() - t)/CLOCKS_PER_SEC);


	printf("chol factor L:\n");
	for(int j=0;j<n;j++){
		for(int p=L->p[j];p<L->p[j+1];p++){
			printf("%d %d %g\n",L->i[p]+1,j+1,L->x[p]);
		}
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1b4a(%rip), %rdi      # 0x3037
leaq 0x1b4d(%rip), %rsi      # 0x3041
callq 0x1130
movq %rax, %rbx
movq %rax, %rdi
callq 0x186a
movq %rax, %r14
movq %rbx, %rdi
callq 0x10f0
movq %r14, %rdi
callq 0x197c
movq %rax, %rbx
movslq 0x8(%rax), %r12
leaq 0x1b8e(%rip), %rdi      # 0x30b3
callq 0x11a0
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1acd
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1c71
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2316
movq %rax, %rbx
callq 0x10b0
subq %r14, %rax
cvtsi2ss %rax, %xmm0
divss 0x1a96(%rip), %xmm0     # 0x3004
cvtss2sd %xmm0, %xmm0
leaq 0x1aca(%rip), %rdi      # 0x3043
movb $0x1, %al
callq 0x1030
leaq 0x1b3c(%rip), %rdi      # 0x30c3
callq 0x11a0
testq %r12, %r12
jle 0x15e6
xorl %r15d, %r15d
leaq 0x1abc(%rip), %r14      # 0x3057
movq %r15, %rax
movq 0x10(%rbx), %rcx
movslq (%rcx,%r15,4), %r13
incq %r15
cmpl 0x4(%rcx,%rax,4), %r13d
jge 0x15e1
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movl (%rax,%r13,4), %esi
incl %esi
movsd (%rcx,%r13,8), %xmm0
movq %r14, %rdi
movl %r15d, %edx
movb $0x1, %al
callq 0x1030
incq %r13
movq 0x10(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r13
jl 0x15b0
cmpq %r12, %r15
jne 0x159b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: sm_insert(smatrix*, int, int, double)
int sm_insert(sm *A,int i,int j,double x){ //insert entry(i,j,x) into triplet form
	if(!TRIPLET(A)||i<0||j<0) return 0;
	if(A->nz >= A->nzmax)smrealloc(A,2*(A->nzmax));
	A->i[A->nz]=i;
	A->p[A->nz]=j;
	A->x[A->nz]=x;
	A->nz++;
	A->m=MAX(A->m,i+1);
	A->n=MAX(A->n,j+1);
	return 1;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x16e4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl 0x28(%rdi), %ecx
orl %esi, %edx
orl %ecx, %edx
js 0x16da
movl (%r14), %esi
cmpl %esi, %ecx
jl 0x1689
addl %esi, %esi
movq %r14, %rdi
movsd %xmm0, -0x20(%rbp)
callq 0x16e5
movsd -0x20(%rbp), %xmm0
movq 0x18(%r14), %rax
movslq 0x28(%r14), %rcx
movl %r15d, (%rax,%rcx,4)
movq 0x10(%r14), %rax
movslq 0x28(%r14), %rcx
movl %ebx, (%rax,%rcx,4)
movq 0x20(%r14), %rax
movslq 0x28(%r14), %rcx
movsd %xmm0, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x28(%r14)
incl %r15d
movl 0x4(%r14), %eax
cmpl %r15d, %eax
cmovgl %eax, %r15d
movl 0x8(%r14), %eax
movl %r15d, 0x4(%r14)
incl %ebx
cmpl %ebx, %eax
cmovgl %eax, %ebx
movl %ebx, 0x8(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: smrealloc(smatrix*, int)
void smrealloc (sm *A, int nzmax)
{
    A->nzmax = (nzmax <= 0) ? (A->p [A->n]) : nzmax ;
    A->i = (int*)realloc (A->i, MAX(nzmax,1)*sizeof(int)) ;
    if (A->nz >= 0) A->p = (int*)realloc (A->p,MAX(nzmax,1)*sizeof(int)) ;
    if (A->x) A->x = (double*)realloc (A->x, MAX(nzmax,1)*sizeof(double)) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
testl %esi, %esi
jg 0x1703
movq 0x10(%rbx), %rax
movslq 0x8(%rbx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rbx)
movq 0x18(%rbx), %rdi
cmpl $0x2, %esi
movl $0x1, %r14d
cmovgel %esi, %r14d
leaq (,%r14,4), %r15
movq %r15, %rsi
callq 0x11d0
movq %rax, 0x18(%rbx)
cmpl $0x0, 0x28(%rbx)
js 0x1740
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x11d0
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1759
shlq $0x3, %r14
movq %r14, %rsi
callq 0x11d0
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: smalloc(int, int, int, int, int)
sm *smalloc(int m, int n, int nzmax, int values, int triplet){
	sm *A = (sm*)calloc(1,sizeof(sm));
	A->m = m ;
	A->n = n ;
	A->nzmax = nzmax;
	A->nz = triplet? 0:-1;
	A->p=(int*)malloc((triplet? nzmax : n+1)*sizeof(int));
	A->i=(int*)malloc(nzmax*sizeof(int));
	A->x=values ? (double*)malloc(nzmax*sizeof(double)) : NULL ;
	return ((!A->p || !A->i || (values && !A->x)) ? smfree (A) : A) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %r13d
movl %edi, %r14d
movl $0x1, %edi
movl $0x30, %esi
callq 0x10a0
movq %rax, %rbx
movl %r14d, 0x4(%rax)
movl %r12d, %r14d
movl %r13d, 0x8(%rax)
movl %r15d, (%rax)
incl %r13d
xorl %eax, %eax
cmpl $0x0, -0x2c(%rbp)
sete %al
cmovnel %r15d, %r13d
negl %eax
movl %eax, 0x28(%rbx)
movslq %r13d, %rdi
shlq $0x2, %rdi
callq 0x1150
movq %rax, %r12
movq %rax, 0x10(%rbx)
movslq %r15d, %r13
leaq (,%r13,4), %rdi
callq 0x1150
movq %rax, %r15
movq %rax, 0x18(%rbx)
testl %r14d, %r14d
je 0x17f4
shlq $0x3, %r13
movq %r13, %rdi
callq 0x1150
jmp 0x17f6
xorl %eax, %eax
testl %r14d, %r14d
setne %cl
movq %rax, 0x20(%rbx)
testq %rax, %rax
sete %al
testq %r12, %r12
je 0x1814
testq %r15, %r15
je 0x1814
andb %al, %cl
je 0x181e
movq %rbx, %rdi
callq 0x1830
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: smfree(smatrix*)
sm *smfree (sm *A){
    if (!A) return (NULL) ;	
    free (A->p) ;
    free (A->i) ;
    free (A->x) ;
    if(A)free(A);
    return NULL;	
}

// Assembly:
testq %rdi, %rdi
je 0x1867
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1140
movq 0x18(%rbx), %rdi
callq 0x1140
movq 0x20(%rbx), %rdi
callq 0x1140
movq %rbx, %rdi
callq 0x1140
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: load(_IO_FILE*)
sm *load (FILE *f){
    int i, j ;   
    double x ;
    sm *A ;
    if (!f) return (NULL) ;                             
    A = smalloc (0, 0, 1, 1, 1) ;                    
    while (fscanf (f, "%d %d %lg\n", &i, &j, &x) == 3)
    {
        if (!sm_insert (A,  i-1,  j-1, x)) return (smfree (A)) ;
    }
    return (A) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x18ed
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x1764
movq %rax, %r14
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
leaq 0x1843(%rip), %rsi      # 0x30f8
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x11f0
cmpl $0x3, %eax
jne 0x18f0
movl -0x30(%rbp), %esi
decl %esi
movl -0x2c(%rbp), %edx
decl %edx
movsd -0x38(%rbp), %xmm0
movq %r14, %rdi
callq 0x1648
testl %eax, %eax
jne 0x18ab
movq %r14, %rdi
callq 0x1830
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: print(smatrix*)
int print(sm *A){
    printf("triplet of %d by %d\n",A->m,A->n);
    printf("  i      j      x \n");
    for(int p=0;p<A->nz;p++){
        printf("%6d %6d %6g\n",A->i[p],A->p[p],A->x[p]);

    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %esi
movl 0x8(%rdi), %edx
leaq 0x17e7(%rip), %rdi      # 0x3103
xorl %eax, %eax
callq 0x1030
leaq 0x181c(%rip), %rdi      # 0x3146
callq 0x11a0
cmpl $0x0, 0x28(%rbx)
jle 0x196f
xorl %r15d, %r15d
leaq 0x17d9(%rip), %r14      # 0x3118
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rcx,%r15,4), %esi
movl (%rax,%r15,4), %edx
movq 0x20(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1030
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x193f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: TripletToCC(smatrix*)
sm *TripletToCC(sm *T){
    int m,n,nz,*Ti,*Tj,*Cp,*Ci,*temp,p;
    double *Cx,*Tx;
    sm *C;
    if(!TRIPLET(T))return NULL;
    m=T->m;
    n=T->n;
    Ti=T->i;
    Tj=T->p;
    Tx=T->x;
    nz=T->nz;
    C=smalloc(m,n,nz,Tx!=NULL,0);
    temp=(int*)calloc(n,sizeof(int));
    Cp=C->p;
    Ci=C->i;
    Cx=C->x;
    //printf("n=%d\n",C->n);
    for(int k=0;k<nz;k++)temp[Tj[k]]++;
    Cp[n]=cumsum(Cp,temp,n);
    for(int k=0;k<nz;k++){
        p=temp[Tj[k]]++;
        Ci[p]=Ti[k];
        Cx[p]=Tx[k];
    }
    return C;

}

// Assembly:
testq %rdi, %rdi
je 0x1a85
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x28(%rdi), %r14
testq %r14, %r14
js 0x1a8a
movl 0x4(%rdi), %eax
movl 0x8(%rdi), %r15d
movq 0x18(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rdi), %r12
movq 0x20(%rdi), %rbx
xorl %ecx, %ecx
testq %rbx, %rbx
setne %cl
xorl %r13d, %r13d
movl %eax, %edi
movl %r15d, %esi
movl %r14d, %edx
xorl %r8d, %r8d
callq 0x1764
movq %rax, -0x38(%rbp)
movl %r15d, -0x2c(%rbp)
movslq %r15d, %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x10a0
testl %r14d, %r14d
je 0x1a03
xorl %ecx, %ecx
movslq (%r12,%rcx,4), %rdx
incl (%rax,%rdx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x19f4
movq -0x38(%rbp), %r9
movq 0x10(%r9), %rsi
movq 0x18(%r9), %rcx
movq 0x20(%r9), %rdx
cmpl $0x0, -0x2c(%rbp)
jle 0x1a38
xorl %edi, %edi
xorl %r8d, %r8d
movl %r8d, (%rsi,%rdi,4)
movl (%rax,%rdi,4), %r13d
addl %r8d, %r13d
movl %r8d, (%rax,%rdi,4)
incq %rdi
movl %r13d, %r8d
cmpq %rdi, %r15
jne 0x1a1e
movl %r13d, (%rsi,%r15,4)
testl %r14d, %r14d
je 0x1a8d
cmpl $0x2, %r14d
movl $0x1, %esi
cmovgel %r14d, %esi
xorl %edi, %edi
movq -0x40(%rbp), %r11
movslq (%r12,%rdi,4), %r8
movslq (%rax,%r8,4), %r9
leal 0x1(%r9), %r10d
movl %r10d, (%rax,%r8,4)
movl (%r11,%rdi,4), %r8d
movl %r8d, (%rcx,%r9,4)
movsd (%rbx,%rdi,8), %xmm0
movsd %xmm0, (%rdx,%r9,8)
incq %rdi
cmpq %rdi, %rsi
jne 0x1a54
movq -0x38(%rbp), %r9
jmp 0x1a8d
xorl %r9d, %r9d
jmp 0x1a9b
xorl %r9d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movq %r9, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: cumsum(int*, int*, int)
int cumsum(int *a,int *b,int n){
    int nz=0;
    for(int i=0;i<n;i++){
        a[i]=nz;
        nz+=b[i];
        b[i]=a[i];
    }
    return nz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
jle 0x1ac9
movl %edx, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
movl %r8d, (%rdi,%rdx,4)
movl (%rsi,%rdx,4), %eax
addl %r8d, %eax
movl %r8d, (%rsi,%rdx,4)
incq %rdx
movl %eax, %r8d
cmpq %rdx, %rcx
jne 0x1aae
jmp 0x1acb
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: buildTree(smatrix*)
et * buildTree(sm *A){
    et *tree=(et*)malloc(sizeof(et));
    int n=A->n,i=0,next=0;
    int *par,*Ap,*Ai,*ancestor;
    map<int,vector<int>* >  *chl;
    vector<int> *t;
    tree->par=(int*)malloc(n*sizeof(int));
    tree->chl=new map<int,vector<int>* >;
    ancestor=(int*)malloc(n*sizeof(int));
    par=tree->par;
    chl=tree->chl;
    Ap=A->p;
    Ai=A->i;
    for(int k=0;k<n;k++){
        par[k]=-1;
        ancestor[k]=-1;
        t= new vector<int>;
        chl->insert(pair<int,vector<int>* >(k,t));
        for(int p=Ap[k];p<Ap[k+1];p++){
            i=Ai[p];
            while(i!=-1 && i<k){
               // printf("%d\n",i);
                next=ancestor[i];
                ancestor[i]=k;
                if(next==-1){

                    par[i]=k;
                    (chl->at(k))->push_back(i);
                }
                i=next;
            }
        }
    }
    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rdi, -0x38(%rbp)
movl $0x10, %edi
callq 0x1150
movq %rax, %r13
movslq 0x8(%rbx), %rax
movq %rax, -0x40(%rbp)
xorl %ebx, %ebx
movl %ebx, -0x30(%rbp)
leaq (,%rax,4), %r12
movq %r12, %rdi
callq 0x1150
movq %rax, %r14
movq %rax, (%r13)
movl $0x30, %edi
callq 0x1100
movq %rax, %r15
addq $0x8, %rax
movl %ebx, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rbx, 0x28(%r15)
movq %r13, -0x50(%rbp)
movq %r15, 0x8(%r13)
movq %r12, %rdi
callq 0x1150
movq %rax, %r12
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, -0x48(%rbp)
movq 0x18(%rcx), %rax
movq %rax, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
cmpq $0x0, -0x40(%rbp)
jle 0x1c5e
movslq %ebx, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%r14,%rbx,4)
movl %eax, (%r12,%rbx,4)
movl $0x18, %edi
callq 0x1100
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl %ebx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
callq 0x25b8
movslq -0x2c(%rbp), %rbx
movq -0x48(%rbp), %rax
movslq (%rax,%rbx,4), %r13
cmpl 0x4(%rax,%rbx,4), %r13d
jge 0x1c4f
movq -0x38(%rbp), %rax
movl (%rax,%r13,4), %ebx
movl %ebx, -0x30(%rbp)
cmpl $-0x1, %ebx
setne %cl
movl -0x2c(%rbp), %eax
cmpl %eax, %ebx
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c36
movslq %ebx, %rcx
movl (%r12,%rcx,4), %ebx
movl %eax, (%r12,%rcx,4)
cmpl $-0x1, %ebx
jne 0x1c27
movl %eax, (%r14,%rcx,4)
movq %r15, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x15f8
movq (%rax), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1c1e
movl -0x30(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1c27
leaq -0x30(%rbp), %rdx
callq 0x270a
movl %ebx, -0x30(%rbp)
cmpl $-0x1, %ebx
je 0x1c36
movl -0x2c(%rbp), %eax
cmpl %eax, %ebx
jl 0x1be2
incq %r13
movslq -0x2c(%rbp), %rbx
movq -0x48(%rbp), %rax
movslq 0x4(%rax,%rbx,4), %rax
cmpq %rax, %r13
jl 0x1bc2
incq %rbx
movl %ebx, -0x2c(%rbp)
cmpl -0x40(%rbp), %ebx
jl 0x1b70
movq -0x50(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: col_structure(etree*, smatrix*)
map<int,vector<int>* > * col_structure(et *e ,sm *A){
    int n=A->n,j;
    map<int,vector<int>* > * col_strut=new map<int,vector<int>* >;
    vector<int> *t;
    int *Ap,*Ai;
    Ap=A->p;
    Ai=A->i;
    int *mark=(int*)malloc(n*sizeof(int));
    for(j=0;j<n;j++){
        t=new vector<int>;
        t->push_back(j);
        col_strut->insert(pair<int,vector<int>* >(j,t));

    }
    for(int i=0;i<n;i++){

        mark[i]=i;
        for(int k=Ap[i];k<Ap[i+1];k++){
            if(Ai[k]<i){
                j=Ai[k];
                while(mark[j]!=i && j!=-1){
                    t=col_strut->at(j);
                    t->push_back(i);
                    mark[j]=i;
                    j=e->par[j];
                }

            }
        }

    }
    return col_strut;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x8(%rsi), %r12
movl $0x30, %edi
callq 0x1100
movq %rax, %r14
addq $0x8, %rax
xorl %r13d, %r13d
movl %r13d, 0x8(%r14)
movq %r13, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r13, 0x28(%r14)
movq 0x10(%r15), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%r15), %rax
movq %rax, -0x58(%rbp)
leaq (,%r12,4), %rdi
callq 0x1150
movq %rax, %r15
movl %r13d, -0x2c(%rbp)
movq %r12, -0x48(%rbp)
testq %r12, %r12
jle 0x1d46
movl $0x18, %edi
callq 0x1100
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x1d13
movl %r13d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r12)
jmp 0x1d1f
movq %r12, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x270a
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq %r12, -0x38(%rbp)
movq %r14, %rdi
leaq -0x40(%rbp), %rsi
callq 0x25b8
movl -0x2c(%rbp), %r13d
incl %r13d
movl %r13d, -0x2c(%rbp)
cmpl -0x48(%rbp), %r13d
jl 0x1ce1
movl $0x0, -0x40(%rbp)
cmpl $0x0, -0x48(%rbp)
jle 0x1e09
xorl %eax, %eax
leaq -0x2c(%rbp), %r12
cltq
movl %eax, (%r15,%rax,4)
movq -0x50(%rbp), %rcx
movslq (%rcx,%rax,4), %r13
movslq -0x40(%rbp), %rax
cmpl 0x4(%rcx,%rax,4), %r13d
jge 0x1dfa
movq -0x58(%rbp), %rcx
movl (%rcx,%r13,4), %ecx
cmpl %eax, %ecx
jge 0x1de5
movl %ecx, -0x2c(%rbp)
cmpl $-0x1, %ecx
je 0x1de5
movslq %ecx, %rax
movl -0x40(%rbp), %ecx
cmpl %ecx, (%r15,%rax,4)
je 0x1de5
movq %r14, %rdi
movq %r12, %rsi
callq 0x15f8
movq (%rax), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1dc1
movl -0x40(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1dca
leaq -0x40(%rbp), %rdx
callq 0x270a
movl -0x40(%rbp), %eax
movslq -0x2c(%rbp), %rcx
movl %eax, (%r15,%rcx,4)
movq (%rbx), %rax
movslq (%rax,%rcx,4), %rax
movl %eax, -0x2c(%rbp)
cmpq $-0x1, %rax
jne 0x1d91
incq %r13
movslq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movslq 0x4(%rcx,%rax,4), %rcx
cmpq %rcx, %r13
jl 0x1d7a
incq %rax
movl %eax, -0x40(%rbp)
cmpl -0x48(%rbp), %eax
jl 0x1d5d
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: fmalloc(int, std::vector<int, std::allocator<int>>*)
Fm *fmalloc(int n,vector<int> *indices){
    Fm *F=(Fm*)malloc(sizeof(Fm));
    F->n=n;
    //if(indices!=NULL)sort(indices->begin(),indices->end());
    F->indices=indices;
    F->x=(double **)calloc(n,sizeof(double *));
    for(int i=0;i<n;i++)
        F->x[i]=(double*)calloc(n,sizeof(double));
    return F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r12d
movl $0x18, %edi
callq 0x1150
movq %rax, %rbx
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movslq %r12d, %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x10a0
movq %rax, 0x10(%rbx)
testl %r14d, %r14d
jle 0x1eb7
movq %rax, %r15
movl %r12d, %r12d
xorl %r13d, %r13d
movl $0x8, %esi
movq %r14, %rdi
callq 0x10a0
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x1e9e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: fconstruct(Fmatrix*, smatrix*, int)
void fconstruct(Fm *F,sm *A,int j){
    int n=F->n,i;
    vector<int> *ind=F->indices;
    double **Fx=F->x;
    Fx[0][0]=sm_access(A,j,j);
    for(int p=1;p<n;p++){
        i=ind->at(p);
        Fx[0][p]=sm_access(A,i,j);
        Fx[p][0]=sm_access(A,i,j);
    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ecx
movq 0x10(%rdi), %r8
movq 0x10(%rsi), %rax
movslq %edx, %r10
movslq (%rax,%r10,4), %r9
movl 0x4(%rax,%r10,4), %r10d
xorps %xmm0, %xmm0
cmpl %r10d, %r9d
jge 0x1f1a
movq 0x18(%rsi), %rax
movl %r10d, %r11d
subl %r9d, %r11d
movq %r9, %rbx
cmpl %edx, (%rax,%rbx,4)
je 0x1f11
incq %rbx
decl %r11d
jne 0x1f02
jmp 0x1f1a
movq 0x20(%rsi), %rax
movsd (%rax,%rbx,8), %xmm0
movq 0x8(%rdi), %rax
movq (%r8), %rdi
movsd %xmm0, (%rdi)
cmpl $0x2, %ecx
jl 0x1fdd
movq (%rax), %r11
movq 0x8(%rax), %rbx
subq %r11, %rbx
sarq $0x2, %rbx
cmpq $0x1, %rbx
movq %rbx, -0x30(%rbp)
adcq $0x0, %rbx
movl %r10d, %edx
subl %r9d, %edx
movl $0x1, %eax
cmpq %rbx, %rax
je 0x1fec
cmpl %r10d, %r9d
jge 0x1f7f
movl (%r11,%rax,4), %r15d
movq 0x18(%rsi), %r12
movq %r9, %r14
cmpl %r15d, (%r12,%r14,4)
je 0x1f8c
incq %r14
cmpl %r14d, %r10d
jne 0x1f6c
xorps %xmm0, %xmm0
jmp 0x1f96
movq $0x0, (%rdi,%rax,8)
xorps %xmm0, %xmm0
jmp 0x1fc8
movq 0x20(%rsi), %r12
movsd (%r12,%r14,8), %xmm0
movsd %xmm0, (%rdi,%rax,8)
xorps %xmm0, %xmm0
cmpl %r10d, %r9d
jge 0x1fc8
movq 0x18(%rsi), %r13
movl %edx, %r14d
movq %r9, %r12
cmpl %r15d, (%r13,%r12,4)
je 0x1fbe
incq %r12
decl %r14d
jne 0x1fad
jmp 0x1fc8
movq 0x20(%rsi), %r14
movsd (%r14,%r12,8), %xmm0
movq (%r8,%rax,8), %r14
movsd %xmm0, (%r14)
incq %rax
cmpq %rcx, %rax
jne 0x1f53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1076(%rip), %rdi      # 0x3069
movq %rax, %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: printFm(Fmatrix*)
void printFm(Fm *F){
    for(int  i=0;i<F->n;i++){
        for(int j=0;j<F->n;j++){
            printf("%6.4g ",F->x[i][j]);
        }
        printf("\n");
    }
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x2066
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x1107(%rip), %r14      # 0x3125
cmpl $0x0, (%rbx)
jle 0x2049
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1030
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x2026
movl $0xa, %edi
callq 0x1160
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x201e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: Fupdate(Fmatrix*, Fmatrix*)
void Fupdate(Fm *F,Fm *U){
    vector<int> *ind=U->indices;
    int i,j;
    for(int k=0;k<U->n;k++){
        i=ind->at(k);
        for(int p=0;p<U->n;p++){
            j=ind->at(p);
            F->x[i][j]+=U->x[k][p];
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq (%rsi), %rcx
testq %rcx, %rcx
jle 0x20cf
movq 0x8(%rsi), %rax
movq (%rax), %r8
movq 0x8(%rax), %rdx
subq %r8, %rdx
sarq $0x2, %rdx
xorl %r9d, %r9d
cmpq %rdx, %r9
je 0x20e7
movslq (%r8,%r9,4), %r10
xorl %eax, %eax
cmpq %rax, %rdx
je 0x20d6
movslq (%r8,%rax,4), %r11
movq 0x10(%rsi), %rbx
movq (%rbx,%r9,8), %rbx
movsd (%rbx,%rax,8), %xmm0
movq 0x10(%rdi), %rbx
movq (%rbx,%r10,8), %rbx
addsd (%rbx,%r11,8), %xmm0
movsd %xmm0, (%rbx,%r11,8)
incq %rax
cmpq %rax, %rcx
jne 0x2095
incq %r9
cmpq %rcx, %r9
jne 0x208a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xf8c(%rip), %rdi       # 0x3069
movq %rax, %rsi
xorl %eax, %eax
callq 0x1190
leaq 0xf7b(%rip), %rdi       # 0x3069
movq %rdx, %rsi
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/tracer.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::format<int, (char)0>(efgy::math::tracer::tracer<int, void, (char)0, efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
static result format(const tracer<T, void, op, formatter> &t) {
    std::stringstream s("");
    if (op) {
      s << "(" << op << t.value1 << ")";
    } else {
      s << t.value1;
    }
    return s.str();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4a07(%rip), %rdx      # 0x17197
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xbc14
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x5390
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x127c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5250
leaq 0x38(%rsp), %rdi
movl 0x8(%r14), %esi
callq 0x53e0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x5380
movq 0xe78e(%rip), %rsi      # 0x20f78
leaq 0x28(%rsp), %rdi
callq 0x51d0
leaq 0xa8(%rsp), %rdi
callq 0x5090
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12853
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5250
jmp 0x12853
movq %rax, %rbx
jmp 0x12853
movq %rax, %rbx
movq 0xe73c(%rip), %rsi      # 0x20f78
leaq 0x28(%rsp), %rdi
callq 0x51d0
leaq 0xa8(%rsp), %rdi
callq 0x5090
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/getc.cc
// Function: main
int main()
{
	int ch;    // use an int, not a char to hold the return from get()

	// loop to read and write all the data in the input
	while ((ch = cin.get()) != EOF)
         	cout.put(ch);
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2e06(%rip), %rdi      # 0x3fe0
callq 0x1070
cmpl $-0x1, %eax
je 0x120a
movq 0x2de5(%rip), %rbx      # 0x3fd0
movq 0x2dee(%rip), %r14      # 0x3fe0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1070
cmpl $-0x1, %eax
jne 0x11f2
movq 0x2dbf(%rip), %rbx      # 0x3fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::addLetter(Letter*)
void Word::addLetter(Letter* letter)
{
    letter->markAsUsed(true);
    mLetters.push(letter);
    mCoords.push_front(letter->coord());
    mWord += letter->letter();
    mScore = mScore + letter->value();
    mMultiplier *= letter->wordMultiplier();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21a0
movq %r14, -0x18(%rbp)
movb $0x0, 0x30(%r14)
movq 0x58(%rbx), %rax
movq 0x68(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x2b2a
movq %r14, (%rax)
addq $0x8, 0x58(%rbx)
jmp 0x2b37
leaq 0x28(%rbx), %rdi
leaq -0x18(%rbp), %rsi
callq 0x434c
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq 0x88(%rbx), %rax
cmpq 0x90(%rbx), %rax
je 0x2b60
movq (%rsi), %rcx
movq %rcx, -0x8(%rax)
addq $-0x8, 0x88(%rbx)
jmp 0x2b69
leaq 0x78(%rbx), %rdi
callq 0x4566
movq -0x18(%rbp), %rax
leaq 0x8(%rbx), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x20a0
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl %ecx, (%rbx)
movl 0xc8(%rbx), %ecx
imull 0x24(%rax), %ecx
movl %ecx, 0xc8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::removeLastLetter()
void Word::removeLastLetter()
{
    Letter* toRemove = mLetters.top();
    mLetters.pop();
    mCoords.pop_front();
    mWord = mWord.substr(0, mWord.length() - toRemove->letter().length());
    mScore = mScore - toRemove->value();
    mMultiplier /= toRemove->wordMultiplier();
    toRemove->markAsUsed(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x21a0
leaq 0x28(%rbx), %rdi
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x2bd2
movq 0x70(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %r12
callq 0x477e
leaq 0x78(%rbx), %rdi
callq 0x39e8
leaq 0x8(%rbx), %r14
movq 0x10(%rbx), %rcx
subq 0x8(%r12), %rcx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2230
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movq (%r15), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x2c1e
callq 0x21e0
movl 0x20(%r12), %eax
subl %eax, (%rbx)
movl 0xc8(%rbx), %eax
cltd
idivl 0x24(%r12)
movl %eax, 0xc8(%rbx)
movb $0x1, 0x30(%r12)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::score() const
int Word::score() const
{ 
    const int base = mScore * mMultiplier;

    int lengthExtra = 0;

    switch (mLetters.size()) {
        case 4:
            lengthExtra = 2;
            break;
        case 5:
            lengthExtra = 4;
            break;
        case 6:
            lengthExtra = 8;
            break;
        case 7:
            lengthExtra = 12;
            break;
        case 8:
            lengthExtra = 18;
            break;
        default:
            break;
    }

    return base + lengthExtra;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21a0
movl (%rbx), %ecx
movl 0xc8(%rbx), %eax
movq 0x70(%rbx), %rdx
movq %rdx, %rsi
subq 0x50(%rbx), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rdx
adcq $-0x1, %rsi
shlq $0x6, %rsi
movq 0x58(%rbx), %rdx
subq 0x60(%rbx), %rdx
sarq $0x3, %rdx
addq %rsi, %rdx
movq 0x48(%rbx), %rsi
subq 0x38(%rbx), %rsi
sarq $0x3, %rsi
leaq (%rsi,%rdx), %r8
addq $-0x4, %r8
xorl %edi, %edi
cmpq $0x4, %r8
ja 0x2cb4
addq %rsi, %rdx
leaq 0x652c(%rip), %rsi      # 0x91dc
movl -0x10(%rsi,%rdx,4), %edi
imull %ecx, %eax
addl %edi, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Letter::toString[abi:cxx11]() const
std::string Letter::toString() const
{
    std::string s = letter();
    s += std::to_string(value());
    s += "-";
    s += std::to_string(wordMultiplier());
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21a0
leaq 0x10(%rbx), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3da6
movl 0x20(%r14), %r15d
movl %r15d, %r12d
negl %r12d
cmovsl %r15d, %r12d
movl $0x1, %r13d
cmpl $0xa, %r12d
jb 0x36f5
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r12d, %ecx
cmpl $0x63, %ecx
jbe 0x36ec
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x36f2
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x36f5
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x36b9
addl $-0x3, %r13d
jmp 0x36f5
addl $-0x2, %r13d
jmp 0x36f5
decl %r13d
shrl $0x1f, %r15d
leal (%r15,%r13), %esi
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x48(%rbp), %rdi
movl $0x2d, %edx
callq 0x2270
addq -0x48(%rbp), %r15
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x3d14
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r13
cmpq %r13, %rdi
je 0x3747
callq 0x21e0
leaq 0x58fb(%rip), %rsi      # 0x9049
movq %rbx, %rdi
callq 0x23b0
movl 0x24(%r14), %r14d
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
movl $0x1, %r12d
cmpl $0xa, %r15d
jb 0x37ba
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0x37b1
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x37b7
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x37ba
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x377e
addl $-0x3, %r12d
jmp 0x37ba
addl $-0x2, %r12d
jmp 0x37ba
decl %r12d
shrl $0x1f, %r14d
leal (%r12,%r14), %esi
leaq -0x48(%rbp), %rdi
movq %r13, (%rdi)
movl $0x2d, %edx
callq 0x2270
addq -0x48(%rbp), %r14
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x3d14
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x3803
callq 0x21e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0x3837
jmp 0x3841
jmp 0x383e
jmp 0x383e
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3841
callq 0x21e0
jmp 0x3841
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x384f
callq 0x21e0
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Board::print()
void Board::print()
{
    for (int i = 0; i < VERTICAL_SIZE; ++i) {
        for (int j = 0; j < HORIZONTAL_SIZE; ++j) {
            std::cout << mLetters[i][j].toString() << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x21a0
xorl %eax, %eax
leaq -0x50(%rbp), %r14
movq 0x974a(%rip), %r15      # 0xcfc8
leaq 0x59ca(%rip), %r12      # 0x924f
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
leaq (%rbx,%r13), %rsi
movq %r14, %rdi
callq 0x3658
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x2260
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2260
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x38ca
callq 0x21e0
addq $0x38, %r13
cmpq $0xe0, %r13
jne 0x388c
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq -0x30(%rbp), %rax
incq %rax
addq $0xe0, %rbx
cmpq $0x4, %rax
jne 0x3885
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x393a
callq 0x21e0
movq %rbx, %rdi
callq 0x2360