LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x37fe
leaq 0x43b5(%rip), %rax      # 0x9988
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_O2/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, %eax
imull %r14d, %eax
movslq %eax, %r13
pushq $0x3
popq %rcx
movq %r13, %rax
mulq %rcx
pushq $-0x1
popq %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, %r12
movb 0x30(%rbx), %al
movb 0x34(%rbx), %cl
movb 0x38(%rbx), %dl
xorl %esi, %esi
testl %r13d, %r13d
cmovlel %esi, %r13d
leaq (,%r13,2), %rdi
addq %r13, %rdi
cmpq %rsi, %rdi
je 0x566d
movb %al, (%r12,%rsi)
movb %cl, 0x1(%r12,%rsi)
movb %dl, 0x2(%r12,%rsi)
addq $0x3, %rsi
jmp 0x5654
addq $0x8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x3936
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3942
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
callq 0x39a8
movq 0x8(%rbx), %rdi
callq 0x38d8
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x38e2
movl %eax, %r15d
imull %r14d, %r15d
movq 0x8(%rbx), %rdi
callq 0x38ec
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
leaq (%r15,%r15,2), %rdx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %rcx, %rdx
je 0x5823
addb (%rax,%rcx), %r12b
addb 0x1(%rax,%rcx), %r15b
addb 0x2(%rax,%rcx), %r14b
addq $0x3, %rcx
jmp 0x580a
leaq 0xaca(%rip), %rdi       # 0x62f4
leaq 0x909(%rip), %rsi       # 0x613a
callq 0x3150
testq %rax, %rax
jne 0x5853
leaq 0xaaf(%rip), %rdi       # 0x62f1
leaq 0x8f1(%rip), %rsi       # 0x613a
callq 0x3150
testq %rax, %rax
je 0x5883
movq %rax, %rbx
movzbl %r12b, %edx
movzbl %r15b, %ecx
movzbl %r14b, %r8d
leaq 0xa98(%rip), %rsi       # 0x6301
movq %rax, %rdi
xorl %eax, %eax
callq 0x3180
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3100
movq 0x4746(%rip), %rax      # 0x9fd0
movq (%rax), %rcx
leaq 0x8a9(%rip), %rdi       # 0x613d
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x31f0
pushq $0x1
popq %rdi
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x45f6(%rip), %rdi      # 0xa178
testq %rdi, %rdi
jne 0x5bc8
leaq 0x884(%rip), %rdi       # 0x6412
leaq 0x51e(%rip), %rsi       # 0x60b3
callq 0x3150
movq %rax, 0x45d7(%rip)      # 0xa178
testq %rax, %rax
jne 0x5bc5
leaq 0x862(%rip), %rdi       # 0x640f
leaq 0x4ff(%rip), %rsi       # 0x60b3
callq 0x3150
movq %rax, 0x45b8(%rip)      # 0xa178
testq %rax, %rax
je 0x5be6
movq %rax, %rdi
leaq 0x866(%rip), %rsi       # 0x6435
movq %rbx, %rdx
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3180
leaq 0x3cc3(%rip), %r15      # 0x98b0
leaq -0x418(%rbp), %rbx
movq %r15, -0x8(%rbx)
movups 0x820(%rip), %xmm0      # 0x641f
movups %xmm0, (%rbx)
movabsq $0x21656c69662067, %rax # imm = 0x21656C69662067
movq %rax, 0xe(%rbx)
movl $0x408, %edi            # imm = 0x408
callq 0x30a0
movq %rax, %r14
movq %r15, (%rax)
leaq 0x8(%rax), %rdi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rsi
callq 0x30d0
leaq 0x3c50(%rip), %rsi      # 0x9888
movq 0x43a1(%rip), %rdx      # 0x9fe0
movq %r14, %rdi
callq 0x31c0
movq %rax, %rbx
leaq -0x420(%rbp), %rdi
callq 0x3208
movq %rbx, %rdi
callq 0x31d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %esi, -0x30(%rbp)
movq %rdi, %r14
leaq -0x2c(%rbp), %r12
leaq 0x1d04(%rip), %r15      # 0x301f
xorl %esi, %esi
movl %esi, -0x2c(%rbp)
cmpl -0x30(%rbp), %esi
jge 0x13a2
movq (%r14), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %edx
leaq 0x1cd3(%rip), %rdi      # 0x3008
xorl %eax, %eax
callq 0x1030
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1576
movq (%rax), %rax
movq 0x8(%rax), %rbx
subq (%rax), %rbx
shrq $0x2, %rbx
testl %ebx, %ebx
movl $0x0, %eax
cmovlel %eax, %ebx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x1390
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1576
movq (%rax), %rdi
movq %r13, %rsi
callq 0x15ae
movl (%rax), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incq %r13
jmp 0x1363
pushq $0xa
popq %rdi
callq 0x1160
movl -0x2c(%rbp), %esi
incl %esi
jmp 0x131d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movl 0x28(%rdi), %eax
movl %eax, -0x30(%rbp)
leaq -0x2c(%rbp), %r15
leaq 0x1c4c(%rip), %r13      # 0x301f
xorl %esi, %esi
movl %esi, -0x2c(%rbp)
cmpl -0x30(%rbp), %esi
jge 0x144e
leaq 0x1c3f(%rip), %rdi      # 0x3023
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1576
movq (%rax), %rax
movq 0x8(%rax), %r12
subq (%rax), %r12
shrq $0x2, %r12
testl %r12d, %r12d
movl $0x0, %eax
cmovlel %eax, %r12d
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x143f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1576
movq (%rax), %rdi
movq %r14, %rsi
callq 0x15ae
movl (%rax), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x1030
incq %r14
jmp 0x1413
pushq $0xa
popq %rdi
callq 0x1160
movl -0x2c(%rbp), %esi
incl %esi
jmp 0x13d5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bc5(%rip), %rdi      # 0x3037
leaq 0x1bc8(%rip), %rsi      # 0x3041
callq 0x1130
movq %rax, %rbx
movq %rax, %rdi
callq 0x184d
movq %rax, %r14
movq %rbx, %rdi
callq 0x10f0
movq %r14, %rdi
callq 0x1953
movq %rax, %rbx
movl 0x8(%rax), %r12d
leaq 0x1c09(%rip), %rdi      # 0x30b3
callq 0x11a0
callq 0x10b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a85
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1bec
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x20df
movq %rax, %rbx
callq 0x10b0
subq %r14, %rax
cvtsi2ss %rax, %xmm0
divss 0x1b11(%rip), %xmm0     # 0x3004
cvtss2sd %xmm0, %xmm0
leaq 0x1b45(%rip), %rdi      # 0x3043
movb $0x1, %al
callq 0x1030
leaq 0x1bb7(%rip), %rdi      # 0x30c3
callq 0x11a0
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
leaq 0x1b35(%rip), %r15      # 0x3057
cmpq %r12, %r14
je 0x1565
movq 0x10(%rbx), %rax
movslq (%rax,%r14,4), %r13
incq %r14
movslq (%rax,%r14,4), %rax
cmpq %rax, %r13
jge 0x1522
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movl (%rax,%r13,4), %esi
incl %esi
movsd (%rcx,%r13,8), %xmm0
movq %r15, %rdi
movl %r14d, %edx
movb $0x1, %al
callq 0x1030
incq %r13
movq 0x10(%rbx), %rax
jmp 0x1532
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16cd
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 0x16c3
movl (%r14), %esi
cmpl %esi, %ecx
jl 0x1675
addl %esi, %esi
movq %r14, %rdi
movsd %xmm0, -0x20(%rbp)
callq 0x16ce
movsd -0x20(%rbp), %xmm0
movl 0x28(%r14), %ecx
movq 0x18(%r14), %rax
movslq %ecx, %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)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16ec
movq 0x10(%rbx), %rax
movslq 0x8(%rbx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rbx)
movq 0x18(%rbx), %rdi
cmpl $0x2, %esi
pushq $0x1
popq %r14
cmovgel %esi, %r14d
leaq (,%r14,4), %r15
movq %r15, %rsi
callq 0x11d0
movq %rax, 0x18(%rbx)
cmpl $0x0, 0x28(%rbx)
js 0x1727
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x11d0
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1740
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_O2/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
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
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 0x17d7
shlq $0x3, %r13
movq %r13, %rdi
callq 0x1150
jmp 0x17d9
xorl %eax, %eax
testl %r14d, %r14d
setne %cl
movq %rax, 0x20(%rbx)
testq %rax, %rax
sete %al
testq %r12, %r12
je 0x17f7
testq %r15, %r15
je 0x17f7
andb %al, %cl
je 0x1801
movq %rbx, %rdi
callq 0x1813
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_O2/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 0x18c8
movq %rdi, %rbx
pushq $0x1
popq %rcx
xorl %edi, %edi
xorl %esi, %esi
movl %ecx, %edx
movl %ecx, %r8d
callq 0x174b
movq %rax, %r14
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
leaq 0x1868(%rip), %rsi      # 0x30f8
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x11f0
cmpl $0x3, %eax
jne 0x18cb
movl -0x30(%rbp), %esi
decl %esi
movl -0x2c(%rbp), %edx
decl %edx
movsd -0x38(%rbp), %xmm0
movq %r14, %rdi
callq 0x1630
testl %eax, %eax
jne 0x1886
movq %r14, %rdi
callq 0x1813
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_O2/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 0x180c(%rip), %rdi      # 0x3103
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x1030
leaq 0x183e(%rip), %rdi      # 0x3146
callq 0x11a0
leaq 0x1804(%rip), %r14      # 0x3118
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x1946
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
jmp 0x1914
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a48
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq 0x28(%rdi), %rbx
testq %rbx, %rbx
js 0x1a4b
movl 0x4(%rdi), %eax
movl 0x8(%rdi), %r15d
movq 0x18(%rdi), %rcx
movq %rcx, -0x58(%rbp)
movq 0x10(%rdi), %r12
movq 0x20(%rdi), %rdx
xorl %ecx, %ecx
movq %rdx, -0x50(%rbp)
testq %rdx, %rdx
setne %cl
xorl %r13d, %r13d
movl %eax, %edi
movl %r15d, %esi
movl %ebx, %edx
xorl %r8d, %r8d
callq 0x174b
movq %rax, %r14
movslq %r15d, %rdi
pushq $0x4
popq %rsi
movq %rdi, -0x38(%rbp)
callq 0x10a0
movq %rax, %r15
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movq %r14, -0x48(%rbp)
movq 0x20(%r14), %r14
cmpq %r13, %rbx
je 0x19e6
movslq (%r12,%r13,4), %rax
incl (%r15,%rax,4)
incq %r13
jmp 0x19d4
movq %rdx, %rdi
movq %rdx, -0x30(%rbp)
movq %r15, %rsi
movq -0x38(%rbp), %r13
movl %r13d, %edx
movq %rcx, -0x40(%rbp)
callq 0x1a5c
movq -0x40(%rbp), %r9
movq -0x30(%rbp), %rcx
movl %eax, (%rcx,%r13,4)
xorl %eax, %eax
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %r8
cmpq %rax, %rbx
je 0x1a42
movslq (%r12,%rax,4), %rcx
movslq (%r15,%rcx,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%r15,%rcx,4)
movl (%rdi,%rax,4), %ecx
movl %ecx, (%r9,%rdx,4)
movsd (%r8,%rax,8), %xmm0
movsd %xmm0, (%r14,%rdx,8)
incq %rax
jmp 0x1a16
movq -0x48(%rbp), %rax
jmp 0x1a4d
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x1a83
movl %eax, (%rdi,%rcx,4)
movl (%rsi,%rcx,4), %r8d
addl %eax, %r8d
movl %eax, (%rsi,%rcx,4)
incq %rcx
movl %r8d, %eax
jmp 0x1a69
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1150
movslq 0x8(%r14), %r13
leaq -0x30(%rbp), %rcx
andl $0x0, (%rcx)
movq %rax, %rbx
movq %r13, -0x50(%rbp)
shlq $0x2, %r13
movq %r13, %rdi
callq 0x1150
movq %rax, -0x40(%rbp)
movq %rax, (%rbx)
pushq $0x30
popq %rdi
callq 0x1100
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rbx, -0x48(%rbp)
movq %rax, -0x38(%rbp)
movq %rax, 0x8(%rbx)
movq %r13, %rdi
callq 0x1150
movq %rax, %r13
movq 0x10(%r14), %rbx
movq 0x18(%r14), %rax
movq %rax, -0x58(%rbp)
xorl %r12d, %r12d
movl %r12d, -0x2c(%rbp)
cmpl -0x50(%rbp), %r12d
jge 0x1bd9
movslq %r12d, %rax
movq -0x40(%rbp), %rcx
orl $-0x1, (%rcx,%rax,4)
orl $-0x1, (%r13,%rax,4)
pushq $0x18
popq %rdi
callq 0x1100
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %r12d, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2356
movslq -0x2c(%rbp), %rax
movslq (%rbx,%rax,4), %r15
movl %eax, %r12d
movslq %r12d, %rcx
movslq 0x4(%rbx,%rcx,4), %rcx
cmpq %rcx, %r15
jge 0x1bd1
movq -0x58(%rbp), %rcx
movl (%rcx,%r15,4), %r14d
movl %r12d, %edx
movl %r14d, %ecx
movl %edx, %r12d
cmpl $-0x1, %r14d
je 0x1bc9
cmpl %r12d, %ecx
jge 0x1bc9
movslq %ecx, %rsi
movl (%r13,%rsi,4), %r14d
movl %r12d, (%r13,%rsi,4)
movl %eax, %edx
cmpl $-0x1, %r14d
jne 0x1b78
movl %ecx, -0x30(%rbp)
movq -0x40(%rbp), %rax
movl %r12d, (%rax,%rsi,4)
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1576
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22ea
movl -0x2c(%rbp), %eax
movl %eax, %edx
jmp 0x1b78
movl %ecx, -0x30(%rbp)
incq %r15
jmp 0x1b60
incl %r12d
jmp 0x1b0e
movq -0x48(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x1100
movq %rax, %r14
addq $0x8, %rax
andl $0x0, 0x8(%r14)
andq $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
andq $0x0, 0x28(%r14)
movq 0x10(%r15), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%r15), %rax
movq %rax, -0x58(%rbp)
movq %r12, -0x38(%rbp)
movq %r12, %rdi
shlq $0x2, %rdi
callq 0x1150
movq %rax, %r15
xorl %eax, %eax
leaq -0x50(%rbp), %r12
movl %eax, -0x2c(%rbp)
cmpl -0x38(%rbp), %eax
jge 0x1c9c
pushq $0x18
popq %rdi
callq 0x1100
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x22ea
movl -0x2c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq %r13, -0x48(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2356
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x1c56
xorl %eax, %eax
leaq -0x2c(%rbp), %r12
leaq -0x50(%rbp), %r13
movl %eax, -0x50(%rbp)
cmpl -0x38(%rbp), %eax
jge 0x1d24
movslq %eax, %rcx
movl %eax, (%r15,%rcx,4)
movq -0x40(%rbp), %rdx
movslq (%rdx,%rcx,4), %rsi
movslq %eax, %rcx
movq -0x40(%rbp), %rdx
movslq 0x4(%rdx,%rcx,4), %rcx
cmpq %rcx, %rsi
jge 0x1d20
movq -0x58(%rbp), %rcx
movq %rsi, -0x60(%rbp)
movl (%rcx,%rsi,4), %ecx
cmpl %eax, %ecx
jge 0x1d17
movl %ecx, -0x2c(%rbp)
cmpl $-0x1, %ecx
je 0x1d17
movslq %ecx, %rcx
cmpl %eax, (%r15,%rcx,4)
je 0x1d17
movq %r14, %rdi
movq %r12, %rsi
callq 0x1576
movq (%rax), %rdi
movq %r13, %rsi
callq 0x22ea
movl -0x50(%rbp), %eax
movslq -0x2c(%rbp), %rcx
movl %eax, (%r15,%rcx,4)
movq (%rbx), %rdx
movl (%rdx,%rcx,4), %ecx
jmp 0x1cdd
movq -0x60(%rbp), %rsi
incq %rsi
jmp 0x1cbd
incl %eax
jmp 0x1ca6
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_O2/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, %r15d
pushq $0x18
popq %rdi
callq 0x1150
movq %rax, %rbx
movl %r15d, (%rax)
movq %r14, 0x8(%rax)
movslq %r15d, %r14
pushq $0x8
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x10a0
movq %rax, %r12
movq %rbx, -0x30(%rbp)
movq %rax, 0x10(%rbx)
xorl %r13d, %r13d
testl %r14d, %r14d
movl $0x0, %ebx
cmovgl %r14d, %ebx
cmpq %r13, %rbx
je 0x1ddc
movq %r14, %rdi
movq %r15, %rsi
callq 0x10a0
movq %rax, (%r12,%r13,8)
incq %r13
jmp 0x1dc3
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movslq (%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdi), %r15
movq %rsi, %rdi
movl %edx, %esi
callq 0x1d36
movq (%r15), %rax
movsd %xmm0, (%rax)
pushq $0x1
popq %r12
cmpq -0x38(%rbp), %r12
jge 0x1e72
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x15ae
movl (%rax), %r13d
movq %r14, %rdi
movl %r13d, %esi
movl %ebx, %edx
callq 0x1d36
movq (%r15), %rax
movsd %xmm0, (%rax,%r12,8)
movq %r14, %rdi
movl %r13d, %esi
movl %ebx, %edx
callq 0x1d36
movq (%r15,%r12,8), %rax
movsd %xmm0, (%rax)
incq %r12
jmp 0x1e2d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x1289(%rip), %r14      # 0x3125
pushq $0xa
popq %r15
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x1ede
xorl %r13d, %r13d
cltq
cmpq %rax, %r13
jge 0x1ed1
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1030
incq %r13
movl (%rbx), %eax
jmp 0x1eab
movl %r15d, %edi
callq 0x1160
incq %r12
jmp 0x1ea0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq 0x8(%rsi), %r15
movl (%rsi), %eax
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x1f67
movq %r15, %rdi
movq %r12, %rsi
callq 0x15ae
movslq (%rax), %r14
xorl %r13d, %r13d
movslq (%rbx), %rax
cmpq %rax, %r13
jge 0x1f62
movq %r15, %rdi
movq %r13, %rsi
callq 0x15ae
movslq (%rax), %rax
movq 0x10(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movsd (%rcx,%r13,8), %xmm0
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx,%r14,8), %rcx
addsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
incq %r13
jmp 0x1f23
incq %r12
jmp 0x1f0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: UpdateF(Fmatrix*, double*, std::vector<int, std::allocator<int>>*)
Fm *UpdateF(Fm *F,double *l_b,vector<int> *Pind){
    Fm *U=(Fm*)malloc(sizeof(Fm));
    U->n=(F->n)-1;
    U->x=(double **)calloc(U->n,sizeof(double *));
    for(int i=0;i<U->n;i++)
        U->x[i]=(double*)calloc(U->n,sizeof(double));
    vector<int> *Gind=F->indices;
    U->indices =new vector<int>;
    int temp=0;
    if(Pind!=NULL)sort(Pind->begin(),Pind->end());
    //printf("Pind:");
    //for(int i=0;i<Pind->size();i++)
      //  printf("%d ",Pind->at(i) );
    //printf("\nGind:");
    //for(int i=0;i<Gind->size();i++)
      //  printf("%d ",Gind->at(i) );  
    

    for(int i=1;i<F->n;i++){
        //temp=0;
        while(Pind->at(temp)!=Gind->at(i))temp++;
        U->indices->push_back(temp);
    }
    //printf("\nLind:");
    //for(int i=0;i<U->indices->size();i++)
    //    printf("%d ",U->indices->at(i) );
    for(int i=0;i<U->n;i++){
        for(int j=0;j<U->n;j++){
            U->x[i][j]=F->x[i+1][j+1]-l_b[i]*l_b[j];
        }
    }

    return U;



}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
pushq $0x18
popq %rdi
callq 0x1150
movq %rax, %r15
movslq (%r12), %rdi
decq %rdi
movq %rdi, -0x38(%rbp)
movl %edi, (%rax)
pushq $0x8
popq %r14
movq %r14, %rsi
callq 0x10a0
movq %r15, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq %rax, 0x10(%r15)
xorl %r15d, %r15d
movq -0x38(%rbp), %rcx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movq %rax, -0x50(%rbp)
cmpq %r15, -0x50(%rbp)
je 0x1ff4
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x10a0
movq -0x48(%rbp), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x1fd5
movq 0x8(%r12), %r15
pushq $0x18
popq %rdi
callq 0x1100
movq %rax, %rcx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq -0x40(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rcx, 0x8(%rax)
andl $0x0, -0x2c(%rbp)
testq %r13, %r13
je 0x2033
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x2652
pushq $0x1
popq %r14
movq %r12, -0x60(%rbp)
movslq (%r12), %rax
cmpq %rax, %r14
jge 0x2085
movl -0x2c(%rbp), %eax
movslq %eax, %rsi
movq %r13, %rdi
callq 0x15ae
movl (%rax), %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x15ae
cmpl (%rax), %r12d
je 0x206f
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
jmp 0x2047
movq -0x58(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x22ea
incq %r14
movq -0x60(%rbp), %r12
jmp 0x203b
movl -0x38(%rbp), %eax
xorl %ecx, %ecx
movq -0x48(%rbp), %rdi
cmpq -0x50(%rbp), %rcx
je 0x20cc
xorl %edx, %edx
cmpq %rdx, %rax
je 0x20c7
movq 0x10(%r12), %rsi
movq 0x8(%rsi,%rcx,8), %rsi
movsd 0x8(%rsi,%rdx,8), %xmm0
movsd (%rbx,%rcx,8), %xmm1
mulsd (%rbx,%rdx,8), %xmm1
subsd %xmm1, %xmm0
movq (%rdi,%rcx,8), %rsi
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x2096
incq %rcx
jmp 0x208e
movq -0x40(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/src/test-case/tracer.cpp
// Function: testTracer(std::ostream&)
bool testTracer(std::ostream &log) {
  std::shared_ptr<tracer<int, void, 0>> frobrt(tracer<int, void, 0>(1));
  runtime frobrt2(new tracer<int, void, 0>(1));
  runtime frobrt3(frobrt);

  auto frobd = frobrt + 2;
  runtime frobde = frobrt + 3;

  frobde /= frobd;

  log << frobd << "\n";
  log << frobde << "\n";

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x1b05e(%rip), %r14     # 0x209d0
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movl $0x1, 0x8(%rsi)
leaq 0x58(%rsp), %rdi
callq 0x63a2
pushq $0x10
popq %rdi
callq 0x5290
movq %r14, (%rax)
movl $0x1, 0x8(%rax)
leaq 0x80(%rsp), %rdi
movq %rax, %rsi
callq 0x131b4
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %r14
movq %r14, %rsi
callq 0x131c0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x131c0
leaq 0x30(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x5be1
leaq 0x18(%rsp), %rdi
callq 0x10024
movq %rsp, %r14
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
callq 0x131c0
leaq 0x6c(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x5be1
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
movaps %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rdi)
callq 0x10024
leaq 0x8(%rsp), %rdi
callq 0x10024
movq %rsp, %rdi
leaq 0x48(%rsp), %rsi
callq 0x133ca
pushq $0x28
popq %rdi
callq 0x5290
movq %rax, %r15
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x104e8
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x10658
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x106f8
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x10726
leaq 0x18(%rsp), %rdi
callq 0x10024
leaq 0x98(%rsp), %rdi
callq 0x10024
leaq 0x8(%rsp), %rdi
callq 0x10024
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0x5aeb
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5260
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x5afd
leaq 0xef15(%rip), %rsi      # 0x14a07
movq %rbx, %rdi
callq 0x5280
movq %rax, %r15
leaq 0xe692(%rip), %rsi      # 0x14196
movq %r15, %rdi
callq 0x5280
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c25
leaq 0xe676(%rip), %rsi      # 0x14196
movq %rax, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x10024
leaq 0x50(%rsp), %rdi
callq 0x10024
leaq 0x78(%rsp), %rdi
callq 0x10024
leaq 0x88(%rsp), %rdi
callq 0x10024
leaq 0x60(%rsp), %rdi
callq 0x10024
movb $0x1, %al
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x5ba6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x5ba9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x5bb3
jmp 0x5b8f
movq %rax, %rbx
jmp 0x5bcf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10024
jmp 0x5ba6
movq %rax, %rbx
movq %r14, %rdi
callq 0x10024
leaq 0x50(%rsp), %rdi
callq 0x10024
leaq 0x78(%rsp), %rdi
callq 0x10024
leaq 0x88(%rsp), %rdi
callq 0x10024
leaq 0x60(%rsp), %rdi
callq 0x10024
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3d36(%rip), %rsi      # 0x14197
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x53e0
leaq 0x10(%rsp), %rdi
callq 0x5120
leaq 0x40(%rsp), %rdi
movl 0x8(%r14), %esi
callq 0x5430
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x53d0
leaq 0x30(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x104e0
movq %rax, %rbx
jmp 0x104e0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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<std::shared_ptr<efgy::math::tracer::base<efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::shared_ptr<efgy::math::tracer::base<efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, (char)47>(efgy::math::tracer::tracer<std::shared_ptr<efgy::math::tracer::base<efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::shared_ptr<efgy::math::tracer::base<efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, (char)47, efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
static result format(const tracer<T, S, op, formatter> &t) {
    std::stringstream s("");
    if (op) {
      s << "(" << t.value1 << " " << op << " " << t.value2 << ")";
    } else {
      s << "(" << t.value1 << " " << t.value2 << ")";
    }
    return s.str();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3c1c(%rip), %rsi      # 0x14197
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x617e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x53e0
leaq 0x10(%rsp), %rdi
callq 0x5120
leaq 0x40(%rsp), %rdi
leaq 0x4453(%rip), %rsi      # 0x14a05
callq 0x5280
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x5c25
leaq 0x44b8(%rip), %rsi      # 0x14a82
movq %rax, %rdi
callq 0x5280
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x5330
leaq 0x449e(%rip), %rsi      # 0x14a82
movq %rax, %rdi
callq 0x5280
addq $0x18, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c25
leaq 0x4401(%rip), %rsi      # 0x14a03
movq %rax, %rdi
callq 0x5280
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x53d0
leaq 0x30(%rsp), %rdi
callq 0x5210
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x10650
movq %rax, %rbx
jmp 0x10650
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2e16(%rip), %rbx      # 0x3fe0
movq 0x2dff(%rip), %r14      # 0x3fd0
movq %rbx, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x11eb
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
jmp 0x11d1
movq 0x2dde(%rip), %rdi      # 0x3fd0
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2180
leaq -0x20(%rbp), %r15
movq %r14, (%r15)
movb $0x0, 0x30(%r14)
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x3e4e
leaq 0x78(%rbx), %rdi
movq (%r15), %rsi
addq $0x28, %rsi
callq 0x325c
movq (%r15), %rsi
leaq 0x8(%rbx), %rdi
callq 0x2390
movq (%r15), %rax
movl 0x20(%rax), %ecx
addl %ecx, (%rbx)
movl 0xc8(%rbx), %ecx
imull 0x24(%rax), %ecx
movl %ecx, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2180
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x2972
movq 0x70(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
leaq 0x28(%rbx), %rdi
movq -0x8(%rax), %r12
callq 0x4362
leaq 0x78(%rbx), %rdi
callq 0x3298
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 0x21f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20f0
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2180
movl (%r14), %r15d
movl 0xc8(%r14), %ebx
addq $0x28, %r14
movq %r14, %rdi
callq 0x3f12
leaq -0x4(%rax), %rdx
xorl %ecx, %ecx
cmpq $0x4, %rdx
ja 0x2a25
leaq 0x574b(%rip), %rcx      # 0x816c
movl -0x10(%rcx,%rax,4), %ecx
imull %r15d, %ebx
addl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::generateScreenCoords[abi:cxx11]() const
std::string Word::generateScreenCoords() const {
    std::deque<Coordinate> coords(mCoords);
    std::string result = "";

    while (!coords.empty()) {
        Coordinate c = coords.back();
        coords.pop_back();

        result += std::to_string(ORIG_COORD_X + c.x()*X_GAP) + " ";
        result += std::to_string(ORIG_COORD_Y + c.y()*Y_GAP) + " ";
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2180
addq $0x78, %r14
leaq -0x98(%rbp), %rdi
movq %r14, %rsi
callq 0x32d4
leaq 0x576f(%rip), %rsi      # 0x81e0
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x20c0
leaq -0xb8(%rbp), %r15
leaq 0x5754(%rip), %r12      # 0x81df
leaq -0x48(%rbp), %r13
movq -0x68(%rbp), %rax
cmpq -0x88(%rbp), %rax
je 0x2b48
cmpq -0x60(%rbp), %rax
jne 0x2ab6
movq -0x50(%rbp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movq -0x8(%rax), %r14
leaq -0x98(%rbp), %rdi
callq 0x3382
imull $0xaa, %r14d, %esi
addl $0x69, %esi
movq %r15, %rdi
callq 0x33f3
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33b7
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2390
shrq $0x20, %r14
movq %r13, %rdi
callq 0x20f0
movq %r15, %rdi
callq 0x20f0
imull $0xae, %r14d, %esi
addl $0x1ab, %esi            # imm = 0x1AB
movq %r15, %rdi
callq 0x33f3
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33b7
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2390
movq %r13, %rdi
callq 0x20f0
movq %r15, %rdi
callq 0x20f0
jmp 0x2a8f
leaq -0x98(%rbp), %rdi
callq 0x3e10
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2b9e
jmp 0x2b74
jmp 0x2b82
jmp 0x2b87
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x20f0
jmp 0x2b8a
movq %rax, %r14
jmp 0x2b96
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x20f0
leaq -0x98(%rbp), %rdi
callq 0x3e10
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movl 0x20(%r14), %esi
leaq -0x30(%rbp), %rdi
callq 0x33f3
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2390
leaq -0x30(%rbp), %rdi
callq 0x20f0
leaq 0x4f9b(%rip), %rsi      # 0x8049
movq %rbx, %rdi
callq 0x2360
movl 0x24(%r14), %esi
leaq -0x30(%rbp), %rdi
callq 0x33f3
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2390
leaq -0x30(%rbp), %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x30ea
jmp 0x30f8
jmp 0x30f8
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x20f0
jmp 0x30fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2180
xorl %eax, %eax
movq 0x9e9a(%rip), %r14      # 0xcfc8
leaq -0x50(%rbp), %r15
leaq 0x50a6(%rip), %r12      # 0x81df
cmpq $0x4, %rax
je 0x3197
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
cmpq $0xe0, %r13
je 0x317f
leaq (%rbx,%r13), %rsi
movq %r15, %rdi
callq 0x3064
movq %r14, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x20f0
addq $0x38, %r13
jmp 0x3146
movq %r14, %rdi
callq 0x2100
movq -0x30(%rbp), %rax
incq %rax
addq $0xe0, %rbx
jmp 0x3139
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2330