LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_list_of_root_nodes()
void create_list_of_root_nodes() {

	root_nodes.clear();

	for (std::list<Octree*>::iterator i = nodes.begin(), end = nodes.end(); i != end; ++i) {
		if((*i)->isRootNode()) 
			root_nodes.push_back(*i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x218f9(%rip), %rdi     # 0x262c8
callq 0x5a50
leaq 0x218bd(%rip), %rdi     # 0x26298
callq 0x4490
movq %rax, -0x8(%rbp)
leaq 0x218ad(%rip), %rdi     # 0x26298
callq 0x44c0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x44f0
testb $0x1, %al
jne 0x4a07
jmp 0x4a43
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6dc0
testb $0x1, %al
jne 0x4a1e
jmp 0x4a36
leaq -0x8(%rbp), %rdi
callq 0x4520
movq %rax, %rsi
leaq 0x21897(%rip), %rdi     # 0x262c8
callq 0x5a80
jmp 0x4a38
leaq -0x8(%rbp), %rdi
callq 0x4550
jmp 0x49f4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_lists_of_level_nodes()
void create_lists_of_level_nodes() {

	//clearing all lists
	for (unsigned level=0; level <= max_level; level++) {
		level_nodes[level].clear();
	}
	

	//pushing nodes to respective lists	
	for (std::list<Octree*>::iterator j = nodes.begin(), end = nodes.end(); j != end; ++j) {
                int level = (*j)->get_level();
		level_nodes[level].push_back(*j);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x21c3b(%rip), %rcx     # 0x266a4
cmpl (%rcx), %eax
ja 0x4a8e
movl -0x4(%rbp), %eax
leaq 0x21869(%rip), %rdi     # 0x262e0
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5a50
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4a5f
leaq 0x21803(%rip), %rdi     # 0x26298
callq 0x4490
movq %rax, -0x10(%rbp)
leaq 0x217f3(%rip), %rdi     # 0x26298
callq 0x44c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x44f0
testb $0x1, %al
jne 0x4ac1
jmp 0x4b0b
leaq -0x10(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6ec0
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x21800(%rip), %rax     # 0x262e0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4520
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5a80
leaq -0x10(%rbp), %rdi
callq 0x4550
jmp 0x4aae
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_lists_of_multilevel_nodes()
void create_lists_of_multilevel_nodes() {

	//clearing all lists
	for (unsigned level=0; level <= max_level; level++) {
		multilevel_nodes[level].clear();
	}

	//pushing nodes to respective lists	
	for (unsigned level=0; level <= max_level; level++) {
		for (std::list<Octree*>::iterator j = nodes.begin(), end = nodes.end(); j != end; ++j) {
                	if(((*j)->get_level()<level && (*j)->isLeafNode())||((*j)->get_level()==level)) { 
				multilevel_nodes[level].push_back(*j);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x21b6b(%rip), %rcx     # 0x266a4
cmpl (%rcx), %eax
ja 0x4b5e
movl -0x4(%rbp), %eax
leaq 0x21979(%rip), %rdi     # 0x264c0
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5a50
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4b2f
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x21b35(%rip), %rcx     # 0x266a4
cmpl (%rcx), %eax
ja 0x4c37
leaq 0x2171a(%rip), %rdi     # 0x26298
callq 0x4490
movq %rax, -0x10(%rbp)
leaq 0x2170a(%rip), %rdi     # 0x26298
callq 0x44c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x44f0
testb $0x1, %al
jne 0x4baa
jmp 0x4c27
leaq -0x10(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6ec0
cmpl -0x8(%rbp), %eax
jae 0x4bd5
leaq -0x10(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6da0
testb $0x1, %al
jne 0x4beb
leaq -0x10(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6ec0
cmpl -0x8(%rbp), %eax
jne 0x4c17
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x218c9(%rip), %rax     # 0x264c0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4520
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x5a80
jmp 0x4c19
leaq -0x10(%rbp), %rdi
callq 0x4550
jmp 0x4b97
jmp 0x4c29
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4b65
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_node(int, double, double, double, double, double, double, int, myOctree::node_boundary_flags**)
void create_node(int blocknumber, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int level, NodeBc **bc) {

	//memory allocation to new node
	Octree r(xmin,xmax,ymin,ymax,zmin,zmax,level);
	nodes.pop_back();
	Octree* root = new Octree(r);

	//boundaries are assigned to this root node
//	root->east_bc = east_bc;
//	root->west_bc = west_bc;
//	root->north_bc = north_bc;
//	root->south_bc = south_bc;
//	root->top_bc = top_bc;
//	root->bottom_bc = bottom_bc;

	for(int i=0;i<3;i++) {
		for(int j=0;j<2;j++) {
			root->bc[i][j] = bc[i][j];
		}
	}

	root->number = blocknumber;
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movq %rdx, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movsd -0x30(%rbp), %xmm4
movsd -0x38(%rbp), %xmm5
movl -0x3c(%rbp), %esi
leaq -0x140(%rbp), %rdi
callq 0x88c0
leaq 0x215f1(%rip), %rdi     # 0x26298
callq 0x5ac0
movl $0xf8, %edi
callq 0x3250
movq %rax, -0x168(%rbp)
jmp 0x4cbf
movq -0x168(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x85d0
jmp 0x4cd4
movq -0x168(%rbp), %rax
movq %rax, -0x148(%rbp)
movl $0x0, -0x158(%rbp)
cmpl $0x3, -0x158(%rbp)
jge 0x4dac
movl $0x0, -0x15c(%rbp)
cmpl $0x2, -0x15c(%rbp)
jge 0x4d96
movq -0x48(%rbp), %rax
movslq -0x158(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x15c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x148(%rbp), %rax
addq $0x38, %rax
movslq -0x158(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x15c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x15c(%rbp)
jmp 0x4d03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
jmp 0x4dd1
movq -0x168(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
movl $0xf8, %esi
callq 0x3260
jmp 0x4dd1
jmp 0x4d98
movl -0x158(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x158(%rbp)
jmp 0x4cec
movl -0x4(%rbp), %ecx
movq -0x148(%rbp), %rax
movl %ecx, 0x98(%rax)
leaq -0x140(%rbp), %rdi
callq 0x8590
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0x140(%rbp), %rdi
callq 0x8590
movq -0x150(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::exchange_ghost_values_of_level(int)
void exchange_ghost_values_of_level(int level) {

	for(int l = 0; l<scalar_fields.size() ; l++) {
		amrsolver::exchange_ghost_val(level, scalar_fields[l]);
	}
	
	for(int l = 0; l<vector_fields.size() ; l++) {
		amrsolver::exchange_ghost_val(level, vector_fields[l]);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x20e14(%rip), %rdi     # 0x266b8
callq 0x5b00
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x5917
movl -0x4(%rbp), %eax
movl %eax, -0x6c(%rbp)
movslq -0x8(%rbp), %rsi
leaq 0x20df2(%rip), %rdi     # 0x266b8
callq 0x5b20
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3120
movl -0x6c(%rbp), %edi
movq -0x68(%rbp), %rsi
callq 0xd220
jmp 0x58e9
leaq -0x28(%rbp), %rdi
callq 0x3180
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3180
jmp 0x59ac
movl $0x0, -0x38(%rbp)
movslq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x20da3(%rip), %rdi     # 0x266d0
callq 0x5b00
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x59a3
movl -0x4(%rbp), %eax
movl %eax, -0x84(%rbp)
movslq -0x38(%rbp), %rsi
leaq 0x20d7e(%rip), %rdi     # 0x266d0
callq 0x5b20
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3120
movl -0x84(%rbp), %edi
movq -0x80(%rbp), %rsi
callq 0xd220
jmp 0x5978
leaq -0x58(%rbp), %rdi
callq 0x3180
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x591e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3180
jmp 0x59ac
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::OctreeGrid()
void OctreeGrid() {

	std::cerr << "\n"  <<"Setting up grid" << std::endl;

	set_root_neighbours();

	//This is to be done after neighbours are set at that particular level
	exchange_ghost_values_of_level(0);

	//prints neighbours information
	//print_neighbour_information(nodes);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20625(%rip), %rdi     # 0x25ff0
leaq 0x1b92f(%rip), %rsi     # 0x21301
callq 0x3240
movq %rax, %rdi
leaq 0x1b76e(%rip), %rsi     # 0x2114f
callq 0x3240
movq %rax, %rdi
movq 0x205d0(%rip), %rsi     # 0x25fc0
callq 0x3270
callq 0x5150
xorl %edi, %edi
callq 0x5880
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/adapt.cpp
// Function: myOctree::refine_nodes()
void refine_nodes() {

        create_list_of_leaf_nodes();

        for (std::list<Octree*>::iterator i = leaf_nodes.begin(), end = leaf_nodes.end(); i != end; ++i) {

                if((*i)->get_level() >= max_level)
                        continue;

                if((*i)->setToRefine)
                        (*i)->refine();

        }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x4930
leaq 0x2010c(%rip), %rdi     # 0x262b0
callq 0x4490
movq %rax, -0x8(%rbp)
leaq 0x200fc(%rip), %rdi     # 0x262b0
callq 0x44c0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x44f0
testb $0x1, %al
jne 0x61d0
jmp 0x621a
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6ec0
cmpl 0x204bd(%rip), %eax     # 0x266a4
jl 0x61eb
jmp 0x620f
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rax
testb $0x1, (%rax)
je 0x620d
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x7220
jmp 0x620f
leaq -0x8(%rbp), %rdi
callq 0x4550
jmp 0x61bd
addq $0x10, %rsp
popq %rbp
retq
// File: suhasjains[P]AMR-Solver/src/adapt.cpp
// Function: myOctree::coarsen_nodes()
void coarsen_nodes() {

        create_list_of_leaf_nodes();

        for (std::list<Octree*>::iterator i = nodes.begin(), end = nodes.end(); i != end;) {

                if((*i)->setToCoarsen && !((*i)->isRootNode()) && ((*i)->isLeafNode())) {

                        //printf("deleting\n");
                        //setting the children of its parent to NULL
                        for(int n=0; n<2; n++) {
                                for(int m=0; m<2; m++) {
                                        for(int l=0; l<2; l++) {
                                                (*i)->get_parent()->set_child_null_at(l, m, n);
                                        }       
                                }       
                        }       

                        i = nodes.erase(i);
                }
                else {
                        ++i;
                }       
        }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x4930
leaq 0x20064(%rip), %rdi     # 0x26298
callq 0x4490
movq %rax, -0x8(%rbp)
leaq 0x20054(%rip), %rdi     # 0x26298
callq 0x44c0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x44f0
testb $0x1, %al
jne 0x6263
jmp 0x6353
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rax
testb $0x1, 0x1(%rax)
je 0x6345
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6dc0
testb $0x1, %al
jne 0x6345
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6da0
testb $0x1, %al
jne 0x62ac
jmp 0x6345
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x631a
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0x630d
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x6300
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6f60
movq %rax, %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x6f20
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x62cd
jmp 0x6302
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x62c0
jmp 0x630f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62b3
leaq -0x30(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x6d30
movq -0x30(%rbp), %rsi
leaq 0x1ff66(%rip), %rdi     # 0x26298
callq 0x6ce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x634e
leaq -0x8(%rbp), %rdi
callq 0x4550
jmp 0x624d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/adapt.cpp
// Function: myOctree::recheck_siblings_coarsen_flags()
void recheck_siblings_coarsen_flags() {

        create_list_of_leaf_nodes();


        for (std::list<Octree*>::iterator it = leaf_nodes.begin(), end = leaf_nodes.end(); it != end; ++it) {
	
		if((*it)->setToCoarsen == true)	{
			
                        for(int n=0; n<2; n++) {
                                for(int m=0; m<2; m++) {
                                        for(int l=0; l<2; l++) {
						if((*it)->get_parent()->get_child_at(l,m,n)->setToCoarsen == false)
							(*it)->setToCoarsen = false;
					}
				}
			}
		}
	}		

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x4930
leaq 0x1f6cc(%rip), %rdi     # 0x262b0
callq 0x4490
movq %rax, -0x8(%rbp)
leaq 0x1f6bc(%rip), %rdi     # 0x262b0
callq 0x44c0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x44f0
testb $0x1, %al
jne 0x6c13
jmp 0x6cd6
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rax
movb 0x1(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6cc6
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x6cc4
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0x6cb4
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x6ca7
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rdi
callq 0x6f60
movq %rax, %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x6ee0
movb 0x1(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6c9a
leaq -0x8(%rbp), %rdi
callq 0x4520
movq (%rax), %rax
movb $0x0, 0x1(%rax)
jmp 0x6c9c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c55
jmp 0x6ca9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6c48
jmp 0x6cb6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c37
jmp 0x6cc6
jmp 0x6cc8
leaq -0x8(%rbp), %rdi
callq 0x4550
jmp 0x6bfd
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/octree.cpp
// Function: myOctree::Octree::get_relative_location(int*, int*, int*)
void Octree::get_relative_location(int* i, int* j, int* k) {

	if(this->isRootNode()) {
             	std::cerr << "Error!: This is root node, no siblings at root node. " << std::endl;
              	exit(1);
       	}

	for(int n=0; n<2; n++) {
		for(int m=0; m<2; m++) {
     			for(int l=0; l<2; l++) {
                      		if(this->get_parent()->get_child_at(l,m,n) == this) {
                              		*i = l;
					*j = m;
					*k = n;
				}
                        }
            	}
       	}	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6dc0
testb $0x1, %al
jne 0x6fab
jmp 0x6fd7
movq 0x1f03e(%rip), %rdi     # 0x25ff0
leaq 0x1a1cf(%rip), %rsi     # 0x21188
callq 0x3240
movq %rax, %rdi
movq 0x1eff8(%rip), %rsi     # 0x25fc0
callq 0x3270
movl $0x1, %edi
callq 0x32e0
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0x706a
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jge 0x705a
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jge 0x704d
movq -0x38(%rbp), %rdi
callq 0x6f60
movq %rax, %rdi
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x6ee0
movq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7040
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x7042
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6ffc
jmp 0x704f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6fef
jmp 0x705c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6fde
addq $0x40, %rsp
popq %rbp
retq
// File: suhasjains[P]AMR-Solver/src/octree.cpp
// Function: myOctree::Octree::set_to_refine_with_nesting()
void Octree::set_to_refine_with_nesting() {

	//set refinement criteria
	this->setToRefine = true;
	
	//check nesting
	if(!(this->isRootNode())) {

		for(int m=0;m<3;m++) {
                	for(int n=0;n<2;n++) {	
				if(this->neighbour[m][n]==NULL && this->bc[m][n]==NONE) {
                      			if(!(this->parent->neighbour[m][n]->setToRefine==true)) { 
                              			this->parent->neighbour[m][n]->set_to_refine_with_nesting();     
                      			}
              			}
			}
		}	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x1, (%rdi)
callq 0x6dc0
testb $0x1, %al
jne 0x716a
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x7168
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jge 0x7158
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7148
movq -0x18(%rbp), %rax
addq $0x38, %rax
movslq -0xc(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x7148
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
addq $0x8, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x7146
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
addq $0x8, %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7070
jmp 0x7148
jmp 0x714a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x70ac
jmp 0x715a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x709b
jmp 0x716a
addq $0x20, %rsp
popq %rbp
retq
// File: suhasjains[P]AMR-Solver/src/octree.cpp
// Function: myOctree::Octree::set_to_coarsen_with_nesting()
void Octree::set_to_coarsen_with_nesting() {
	
	bool criteria;	
	criteria = true;

	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			if(this->neighbour[m][n]) {
		//std::cerr << "\n" << "hi" << std::endl;
              			if(!(this->neighbour[m][n]->isLeafNode())) {
                      			criteria = false;
              			}
      			}     	
		}
	}	

	this->setToCoarsen = criteria;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x7204
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x71f7
movq -0x20(%rbp), %rax
addq $0x8, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x71ea
movq -0x20(%rbp), %rax
addq $0x8, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6da0
testb $0x1, %al
jne 0x71e8
movb $0x0, -0x9(%rbp)
jmp 0x71ea
jmp 0x71ec
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x719c
jmp 0x71f9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x718f
movq -0x20(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/vecfield.cpp
// Function: myOctree::VecField::set_field(double)
void VecField::set_field(double value) {

        for(int i=0;i<this->Nx;i++) {
                for(int j=0;j<this->Ny;j++) {
                        for(int k=0;k<this->Nz;k++) {
                                this->x[i][j][k] = value;
                                this->y[i][j][k] = value;
                                this->z[i][j][k] = value;
                        }
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0xb81d
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xb80d
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xb7fd
movq -0x28(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movsd -0x10(%rbp), %xmm0
movq 0x18(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movsd -0x10(%rbp), %xmm0
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb779
jmp 0xb7ff
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb762
jmp 0xb80f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb74c
popq %rbp
retq
nop
// File: suhasjains[P]AMR-Solver/src/vecfield.cpp
// Function: myOctree::VecField::~VecField()
VecField::~VecField() {
                //std::cerr << "destructor of vecfield is working" << std::endl;

        for (int i = 0; i < Nx; ++i) {
                for (int j = 0; j < Ny; ++j) {
                        delete [] x[i][j];
                        delete [] y[i][j];
                        delete [] z[i][j];
                }
                delete [] x[i];
                delete [] y[i];
                delete [] z[i];
        }

        delete [] x;
        delete [] y;
        delete [] z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc03b
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xbfc2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbf5c
movq -0x20(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbf87
movq -0x28(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbfb2
movq -0x30(%rbp), %rdi
callq 0x3330
jmp 0xbfb4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbf21
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xbfe5
movq -0x38(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xc008
movq -0x40(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xc02b
movq -0x48(%rbp), %rdi
callq 0x3330
jmp 0xc02d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbf0b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xc056
movq -0x50(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xc071
movq -0x58(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xc08c
movq -0x60(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
nop
// File: suhasjains[P]AMR-Solver/src/field.cpp
// Function: myOctree::Field::Field(int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Field::Field( int N_x, int N_y, int N_z, std::string info ) : Nx(N_x), Ny(N_y), Nz(N_z), name(info)  {
        //      std::cerr << "parametrized constructor of field is working" << std::endl;

        N = Nx*Ny*Nz;
        val = new double** [Nx];
        for(int i=0;i<Nx;i++) {
                val[i] = new double* [Ny];
                for(int j=0;j<Ny;j++) {
                        val[i][j] = new double [Nz];
                }
        }
	
	set_field(0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r8, -0x58(%rbp)
movl %esi, %eax
movq -0x58(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x4(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3120
movq -0x48(%rbp), %rax
movl (%rax), %ecx
movl 0x4(%rax), %edx
imull %edx, %ecx
movl 0x8(%rax), %edx
imull %edx, %ecx
movl %ecx, 0xc(%rax)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x40(%rbp)
jmp 0xc122
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc20b
movq -0x48(%rbp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x60(%rbp)
jmp 0xc16d
movq -0x60(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x34(%rbp)
movq -0x48(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xc1fb
movq -0x48(%rbp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x68(%rbp)
jmp 0xc1bd
movq -0x68(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc188
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3180
jmp 0xc21f
jmp 0xc1fd
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xc135
movq -0x48(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xc230
jmp 0xc219
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/field.cpp
// Function: myOctree::Field::set_field(double)
void Field::set_field(double value) {

        for(int i=0;i<this->Nx;i++) {
                for(int j=0;j<this->Ny;j++) {
                        for(int k=0;k<this->Nz;k++) {
                                this->val[i][j][k] = value;
                        }
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc2c8
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xc2bb
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xc2ae
movq -0x28(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc271
jmp 0xc2b0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc25e
jmp 0xc2bd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc24c
popq %rbp
retq
nopw (%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/field.cpp
// Function: myOctree::Field::Field()
Field::Field() {
        //      std::cerr << "default constructor of field is working" << std::endl;

        Nx = 0;
        Ny = 0;
        Nz = 0;
        N = Nx*Ny*Nz;
        val = new double** [Nx];
        for(int i=0;i<Nx;i++) {
                val[i] = new double* [Ny];
                for(int j=0;j<Ny;j++) {
                        val[i][j] = new double [Nz];
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3360
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl (%rax), %ecx
movl 0x4(%rax), %edx
imull %edx, %ecx
movl 0x8(%rax), %edx
imull %edx, %ecx
movl %ecx, 0xc(%rax)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x28(%rbp)
jmp 0xc33e
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc427
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x40(%rbp)
jmp 0xc389
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xc417
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x48(%rbp)
jmp 0xc3d9
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc3a4
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3180
jmp 0xc42d
jmp 0xc419
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc351
addq $0x50, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/field.cpp
// Function: myOctree::Field::~Field()
Field::~Field() {
        //      std::cerr << "delete constructor of field is working" << std::endl;

        for (int i = 0; i < Nx; ++i) {
                for (int j = 0; j < Ny; ++j)
                        delete [] val[i][j];

                delete [] val[i];
                }

        delete [] val;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xc6e4
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xc6b1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc6a4
movq -0x20(%rbp), %rdi
callq 0x3330
jmp 0xc6a6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc66d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xc6d4
movq -0x28(%rbp), %rdi
callq 0x3330
jmp 0xc6d6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc65b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xc6ff
movq -0x30(%rbp), %rdi
callq 0x3330
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x3180
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/vtk.cpp
// Function: myOctree::get_point(int, int, int, int, int)
long int get_point(int i, int j, int k, int Npx, int Npy) {

	int I = i+1;
	int J = j+1;
	int K = k+1;
	
	long int n;

	n = k * Npx * Npy + j * Npx + I; 	

	return n-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/output.cpp
// Function: std::NodeBc_to_string[abi:cxx11](myOctree::node_boundary_flags)
string NodeBc_to_string(myOctree::NodeBc bcc) {

	string bc;

	if(bcc==myOctree::NONE) 
		bc = "N";

	if(bcc==myOctree::BOUNDARY) 
		bc = "B";

	if(bcc==myOctree::MPI_BOUNDARY) 
		bc = "MB";


	return bc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x3360
cmpl $0x0, -0xc(%rbp)
jne 0x13784
movq -0x30(%rbp), %rdi
leaq 0xdc5b(%rip), %rsi      # 0x213bf
callq 0x3350
jmp 0x1376b
jmp 0x13784
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3180
jmp 0x137d5
cmpl $0x1, -0xc(%rbp)
jne 0x1379e
movq -0x30(%rbp), %rdi
leaq 0xdc2d(%rip), %rsi      # 0x213c2
callq 0x3350
jmp 0x1379c
jmp 0x1379e
cmpl $0x2, -0xc(%rbp)
jne 0x137b8
movq -0x30(%rbp), %rdi
leaq 0xdc12(%rip), %rsi      # 0x213c1
callq 0x3350
jmp 0x137b6
jmp 0x137b8
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x137cb
movq -0x30(%rbp), %rdi
callq 0x3180
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3420
nop
// File: suhasjains[P]AMR-Solver/src/input.cpp
// Function: std::string_to_NodeBc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
myOctree::NodeBc string_to_NodeBc(string bc) {

	myOctree::NodeBc bcc;

	if(bc=="N")
		bcc = myOctree::NONE;

	if(bc=="B")
		bcc = myOctree::BOUNDARY;

	if(bc=="MPI_BOUNDARY")
		bcc = myOctree::MPI_BOUNDARY;
		
	return bcc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xd3d8(%rip), %rsi      # 0x213bf
callq 0x169d0
testb $0x1, %al
jne 0x13ff2
jmp 0x13ff9
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd3be(%rip), %rsi      # 0x213c2
callq 0x169d0
testb $0x1, %al
jne 0x1400f
jmp 0x14016
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd3cf(%rip), %rsi      # 0x213f0
callq 0x169d0
testb $0x1, %al
jne 0x1402c
jmp 0x14033
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/input.cpp
// Function: std::string_to_FieldBc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
myOctree::FieldBc string_to_FieldBc(string bc) {

	myOctree::FieldBc bcc;

	if(bc=="N")
		bcc = myOctree::none;

	if(bc=="D")
		bcc = myOctree::dirichlet;
	
	if(bc=="NE")
		bcc = myOctree::neumann;

	if(bc=="MB")
		bcc = myOctree::mpi_boundary;
		
	return bcc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xd368(%rip), %rsi      # 0x213bf
callq 0x169d0
testb $0x1, %al
jne 0x14062
jmp 0x14069
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd389(%rip), %rsi      # 0x213fd
callq 0x169d0
testb $0x1, %al
jne 0x1407f
jmp 0x14086
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd36e(%rip), %rsi      # 0x213ff
callq 0x169d0
testb $0x1, %al
jne 0x1409c
jmp 0x140a3
movl $0x2, -0xc(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd313(%rip), %rsi      # 0x213c1
callq 0x169d0
testb $0x1, %al
jne 0x140b9
jmp 0x140c0
movl $0x3, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suhasjains[P]AMR-Solver/src/input.cpp
// Function: std::read_max_level(std::basic_ifstream<char, std::char_traits<char>>&)
void read_max_level(ifstream& file) {

	string line, str;
	
	//Skips if a line is empty		
	getline(file, line);
	while(line.empty()) {
		getline(file, line);
	}

	if(line=="max_level") {

		file >> myOctree::max_level;
	
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3360
leaq -0x48(%rbp), %rdi
callq 0x3360
movq -0x60(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3090
jmp 0x16741
jmp 0x16743
leaq -0x28(%rbp), %rdi
callq 0x33f0
testb $0x1, %al
jne 0x16752
jmp 0x16783
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3090
jmp 0x16761
jmp 0x16743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
leaq -0x28(%rbp), %rdi
callq 0x3180
jmp 0x167cd
leaq 0xad83(%rip), %rsi      # 0x2150d
leaq -0x28(%rbp), %rdi
callq 0x169d0
movb %al, -0x61(%rbp)
jmp 0x16798
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x167a1
jmp 0x167b5
movq -0x8(%rbp), %rdi
leaq 0xfef8(%rip), %rsi      # 0x266a4
callq 0x3170
jmp 0x167b3
jmp 0x167b5
leaq -0x48(%rbp), %rdi
callq 0x3180
leaq -0x28(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: suhasjains[P]AMR-Solver/src/input.cpp
// Function: std::read_input_file()
void read_input_file() {

	int blocknumber;
	string line, str;

	ifstream file ("../input/input.pfs"); 
	if(file.fail()) {
		cerr << "Error opening input file\n";
		exit(1);
	}

	if(file.peek() == ifstream::traits_type::eof()) {
		cerr << "Nothing in the input file\n";
		exit(1);
	}

	else {

		cerr << "\nReading input files" << endl;

		read_scalar_fields(file);

		read_vector_fields(file);
	
		blocknumber = read_blocks(file);

		read_scalar_field_Bc(file, blocknumber);

		read_vector_field_Bc(file, blocknumber);

		read_max_level(file);

	}

	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
leaq -0x28(%rbp), %rdi
callq 0x3360
leaq -0x48(%rbp), %rdi
callq 0x3360
leaq 0xad13(%rip), %rsi      # 0x21517
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x3470
jmp 0x16817
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x25d(%rbp)
jmp 0x16837
movb -0x25d(%rbp), %al
testb $0x1, %al
jne 0x16843
jmp 0x1689c
movq 0xf7a6(%rip), %rdi      # 0x25ff0
leaq 0xab7e(%rip), %rsi      # 0x213cf
callq 0x3240
jmp 0x16858
movl $0x1, %edi
callq 0x32e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x169b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x30b0
jmp 0x169b1
leaq -0x250(%rbp), %rdi
callq 0x30f0
movl %eax, -0x264(%rbp)
jmp 0x168b0
callq 0x16aa0
movl %eax, %ecx
movl -0x264(%rbp), %eax
cmpl %ecx, %eax
jne 0x168e0
movq 0xf728(%rip), %rdi      # 0x25ff0
leaq 0xac5b(%rip), %rsi      # 0x2152a
callq 0x3240
jmp 0x168d6
movl $0x1, %edi
callq 0x32e0
movq 0xf709(%rip), %rdi      # 0x25ff0
leaq 0xac57(%rip), %rsi      # 0x21545
callq 0x3240
movq %rax, -0x270(%rbp)
jmp 0x168fc
movq -0x270(%rbp), %rdi
movq 0xf6b6(%rip), %rsi      # 0x25fc0
callq 0x3270
jmp 0x16911
leaq -0x250(%rbp), %rdi
callq 0x140d0
jmp 0x1691f
leaq -0x250(%rbp), %rdi
callq 0x142f0
jmp 0x1692d
leaq -0x250(%rbp), %rdi
callq 0x14510
movl %eax, -0x274(%rbp)
jmp 0x16941
movl -0x274(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq -0x250(%rbp), %rdi
callq 0x14c60
jmp 0x1695b
movl -0x4(%rbp), %esi
leaq -0x250(%rbp), %rdi
callq 0x154f0
jmp 0x1696c
leaq -0x250(%rbp), %rdi
callq 0x16710
jmp 0x1697a
jmp 0x1697c
leaq -0x250(%rbp), %rdi
callq 0x30a0
jmp 0x1698a
leaq -0x250(%rbp), %rdi
callq 0x30b0
leaq -0x48(%rbp), %rdi
callq 0x3180
leaq -0x28(%rbp), %rdi
callq 0x3180
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x3180
leaq -0x28(%rbp), %rdi
callq 0x3180
movq -0x258(%rbp), %rdi
callq 0x3420
nop
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/strategy.cpp
// Function: strgy2(std::vector<std::bitset<32ul>, std::allocator<std::bitset<32ul>>>&)
vector<xpair> strgy2(vector<ROW> &m)
{
	vector<ROW> trans_m;
	get_trans_matrix(trans_m, m);
	vector<xpair> seq = strgy1(trans_m);
	for(int i = 0; i < seq.size(); i++)
	{
		seq[i].flag = true;
	}
	get_trans_matrix(m, trans_m);

	int tab[SIZE] = {0};
	build_table(m, tab);//get TABLE
	vector<xpair> final_seq = update_seq_str(seq, tab);
	return final_seq;
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
leaq 0x150(%rsp), %rdi
callq 0x5e50
movq 0x168(%rsp), %rsi
leaq 0x138(%rsp), %rdi
callq 0x2fc0
jmp 0x4958
leaq 0x150(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x4c10
jmp 0x496f
leaq 0x138(%rsp), %rdi
callq 0x30c0
leaq 0x110(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x45e0
jmp 0x4993
movl $0x0, 0x10c(%rsp)
movslq 0x10c(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x3280
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x4a30
movslq 0x10c(%rsp), %rsi
leaq 0x110(%rsp), %rdi
callq 0x3430
movb $0x1, 0x8(%rax)
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
jmp 0x499e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
jmp 0x4bed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
leaq 0x138(%rsp), %rdi
callq 0x30c0
jmp 0x4bed
movq 0x168(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xf0(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x2fc0
jmp 0x4a54
movq 0x18(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x4c10
jmp 0x4a68
leaq 0xf0(%rsp), %rdi
callq 0x30c0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movq 0x168(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x2fc0
jmp 0x4acd
leaq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4da0
jmp 0x4ade
leaq 0x58(%rsp), %rdi
callq 0x30c0
movb $0x0, 0x57(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x3120
jmp 0x4b01
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x4e90
jmp 0x4b17
leaq 0x38(%rsp), %rdi
callq 0x3220
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x4bb9
jmp 0x4baf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
jmp 0x4be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x30c0
jmp 0x4be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x30c0
jmp 0x4be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3220
jmp 0x4be0
movq 0x28(%rsp), %rdi
callq 0x3220
leaq 0x110(%rsp), %rdi
callq 0x3220
leaq 0x150(%rsp), %rdi
callq 0x30c0
movq 0x30(%rsp), %rax
addq $0x178, %rsp            # imm = 0x178
retq
leaq 0x110(%rsp), %rdi
callq 0x3220
leaq 0x150(%rsp), %rdi
callq 0x30c0
movq 0x130(%rsp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/strategy.cpp
// Function: get_trans_matrix(std::vector<std::bitset<32ul>, std::allocator<std::bitset<32ul>>>&, std::vector<std::bitset<32ul>, std::allocator<std::bitset<32ul>>>)
void get_trans_matrix(vector<ROW> &trans_m, vector<ROW> m)
{   
	trans_m.clear();
	for(int i = 0; i < m.size(); i++)
	{  
		bitset<SIZE> tmp(0);
		for (int j = 0; j < m.size(); j++)
		{
		tmp[m[0].size() - 1 - j] = m[j][m[0].size() - i - 1];
		}
		trans_m.push_back(tmp);
	}
}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x60c0
movl $0x0, 0x74(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x74(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x32a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x4d89
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x60e0
movl $0x0, 0x64(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x64(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x32a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x4d67
movq 0x28(%rsp), %rdi
movslq 0x64(%rsp), %rsi
callq 0x33d0
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0x10(%rsp)
callq 0x33d0
movq %rax, %rdi
callq 0x5d40
movq 0x8(%rsp), %rsi
movslq 0x74(%rsp), %rdx
notq %rdx
addq %rax, %rdx
leaq 0x50(%rsp), %rdi
callq 0x5d50
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x33d0
movq %rax, %rdi
callq 0x5d40
movslq 0x64(%rsp), %rdx
notq %rdx
addq %rax, %rdx
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x5d50
jmp 0x4d1a
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6130
leaq 0x40(%rsp), %rdi
callq 0x5dd0
leaq 0x50(%rsp), %rdi
callq 0x5dd0
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x4c79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5dd0
jmp 0x4d91
movq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x61d0
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x4c3e
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: xiangzejun[P]Optimizing_Implementations_of_Linear_Layers/strategy.cpp
// Function: build_table(std::vector<std::bitset<32ul>, std::allocator<std::bitset<32ul>>>, int*)
void build_table(vector<ROW> m, int tab[SIZE])
{
	int ind = 0;
	for (int i = 0; i < m.size(); i++)
	{
		for (int j = 0; j < m.size(); j++)
		{
			if (m[i].test(j))
			{
				ind = m.size() - 1 - j;
				break;
			}
		}
		tab[ind] = i;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x32a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4e7d
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, (%rsp)
callq 0x32a0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x4e5c
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x33d0
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x33f0
testb $0x1, %al
jne 0x4e31
jmp 0x4e4d
movq 0x10(%rsp), %rdi
callq 0x32a0
subq $0x1, %rax
movslq 0x1c(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x24(%rsp)
jmp 0x4e5c
jmp 0x4e4f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4df0
movl 0x20(%rsp), %edx
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x4dc3
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)