LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rtrie.cc
// Function: rt_insert(rnode*, rg, pc_rule*)
void rt_insert(rnode *n, rg r, pc_rule* index)
{
    if(r.high >= n->b.high && r.low <= n->b.low) {
        n->rlist.push_back(index);
        return;
    }

    uint32_t m = (n->b.high -  n->b.low + 1ULL)/2 + n->b.low - 1;

    if(r.low <= m) {
        if(!n->left) {
            n->left = new rnode(rg(n->b.low, m));
        }

        rt_insert(n->left, r, index);
    }

    if(r.high > m) {
        if(!n->right) {
            n->right = new rnode(rg(m+1, n->b.high)); 
        }
        rt_insert(n->right, r, index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rdx, -0x40(%rbp)
movl (%rsi), %r12d
movl 0x4(%rsi), %r8d
movl (%rdi), %r13d
movl 0x4(%rdi), %ebx
cmpl %ebx, %r8d
setb %al
cmpl %r13d, %r12d
seta %cl
orb %al, %cl
je 0x5499
movq %rsi, %r15
subl %r13d, %ebx
incq %rbx
shrq %rbx
leal (%rbx,%r13), %eax
decl %eax
cmpl %eax, %r12d
jbe 0x54ae
movq %rdx, %r12
jmp 0x550c
addq $0x8, %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x4c7a
jmp 0x5561
movl %eax, -0x2c(%rbp)
movq 0x28(%r14), %rdi
testq %rdi, %rdi
jne 0x54f2
pushq $0x30
popq %rdi
movq %rdx, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
callq 0x2150
movl -0x30(%rbp), %r8d
movq -0x38(%rbp), %rdx
movq %rax, %rdi
movl %r13d, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdi, 0x28(%r14)
leaq -0x50(%rbp), %rsi
movl %r12d, (%rsi)
movl %r8d, 0x4(%rsi)
movq %rdx, %r12
callq 0x5448
movl 0x4(%r15), %r8d
movl -0x2c(%rbp), %eax
cmpl %eax, %r8d
jbe 0x5561
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x554c
addl %ebx, %r13d
pushq $0x30
popq %rdi
movl %r8d, %ebx
callq 0x2150
movl %ebx, %r8d
movq %rax, %rdi
movl 0x4(%r14), %eax
movl %r13d, (%rdi)
movl %eax, 0x4(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdi, 0x20(%r14)
movl (%r15), %eax
leaq -0x48(%rbp), %rsi
movl %eax, (%rsi)
movl %r8d, 0x4(%rsi)
movq %r12, %rdx
callq 0x5448
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rtrie.cc
// Function: rt_destory(rnode*)
void rt_destory(rnode *n)
{
    if(!n)
        return;

    if(n->right){
        rt_destory(n->right);
        n->right = NULL;
    }

    if(n->left){
        rt_destory(n->left);
        n->left = NULL;
    }

    n->rlist.clear();
    delete n;
}

// Assembly:
testq %rdi, %rdi
je 0x55c9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x5591
callq 0x5570
andq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x55a4
callq 0x5570
andq $0x0, 0x28(%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x55b6
movq %rax, 0x10(%rbx)
callq 0x2c06
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2120
retq
// File: /workspace/github_cpp_makefile_star2_O2/derekzwy[P]an-optimal-tcam-encoding-algorithm-for-packet-classification/rtrie.cc
// Function: rt_query_or(rnode*, rg, std::vector<pc_rule*, std::allocator<pc_rule*>>&)
void rt_query_or(rnode *n, rg r, vector<pc_rule*> &set) 
{
    if(!n){ 
        return;
    }
    vector<pc_rule*> set_left;
    vector<pc_rule*> set_right;
    

    copy(n->rlist.begin(), n->rlist.end(), back_inserter(set));
    uint32_t m = ((uint64_t)n->b.high -  (uint64_t)n->b.low + 1ULL)/2 + n->b.low - 1;

    if(r.low <= m) {
        rt_query_or(n->left, r, set_left);
    }
    if(r.high > m) {
        rt_query_or(n->right, r, set_right);
    }

    if(!set_left.empty() && !set_right.empty()) {
        sort(set_left.begin(), set_left.end());
        sort(set_right.begin(), set_right.end());

        set_union(set_left.begin(), set_left.end(),
                set_right.begin(), set_right.end(),
                back_inserter(set));
    }
    else if(!set_left.empty()) {
        copy(set_left.begin(), set_left.end(), back_inserter(set));
    }
    else if(!set_right.empty()) {
        copy(set_right.begin(), set_right.end(), back_inserter(set));
    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x593f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, -0x50(%rbp)
xorps %xmm0, %xmm0
andq $0x0, -0x30(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x40(%rbp)
movq 0x8(%rdi), %rdi
movq 0x10(%r15), %rsi
callq 0x5afa
movl (%r15), %eax
movl 0x4(%r15), %ecx
subq %rax, %rcx
incq %rcx
shrq %rcx
leal (%rax,%rcx), %r12d
decl %r12d
movl (%r14), %eax
cmpl %r12d, %eax
ja 0x58aa
movq 0x28(%r15), %rdi
leaq -0x70(%rbp), %rsi
movl %eax, (%rsi)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rsi)
leaq -0x60(%rbp), %rdx
callq 0x582e
movl 0x4(%r14), %eax
cmpl %r12d, %eax
jbe 0x58cc
movq 0x20(%r15), %rdi
movl (%r14), %ecx
leaq -0x68(%rbp), %rsi
movl %ecx, (%rsi)
movl %eax, 0x4(%rsi)
leaq -0x40(%rbp), %rdx
callq 0x582e
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
cmpq %rax, %rcx
je 0x5918
cmpq %rsi, %rdi
je 0x591f
movq %rcx, %rdi
movq %rax, %rsi
callq 0x4e43
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4e43
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rbx, %r8
callq 0x5b3b
jmp 0x592d
cmpq %rsi, %rdi
jne 0x5925
jmp 0x592d
movq %rcx, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5afa
leaq -0x40(%rbp), %rdi
callq 0x2c06
leaq -0x60(%rbp), %rdi
callq 0x2c06
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x594e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2c06
leaq -0x60(%rbp), %rdi
callq 0x2c06
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/amrsolver.cpp
// Function: amrsolver::set_field()
void set_field() {

	myOctree::create_list_of_leaf_nodes();

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

   		Field* field = (*it)->get_block_data()->scalarfields[1];
   		VecField* location = (*it)->get_block_data()->mesh;
	
		for(int i=0;i<field->Nx;i++) {
                	for(int j=0;j<field->Ny;j++) {
                        	for(int k=0;k<field->Nz;k++) {
				
					double x = location->x[i][j][k];
					double y = location->y[i][j][k];
					double z = location->z[i][j][k];
 					
					if((*it)->get_block_data()->flag[i][j][k]==myOctree::DOMAIN) 
						field->val[i][j][k] = 1.0;		
					//if(x*x + y*y >= 3.0)	{field->val[i][j][k] = 100.0; }		
                        	}
                	}
        	}

    	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2dec
leaq 0x107f0(%rip), %r15     # 0x13210
movq (%r15), %r15
cmpq 0x1058e(%rip), %r15     # 0x12fb8
je 0x2ab8
movq 0x10(%r15), %rdi
callq 0x3db0
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
movq 0x10(%r15), %rdi
callq 0x3db0
xorl %r13d, %r13d
movslq (%r12), %rax
cmpq %rax, %r13
jge 0x2a20
xorl %ebx, %ebx
movslq 0x4(%r12), %rax
cmpq %rax, %rbx
jge 0x2ab3
xorl %r14d, %r14d
movslq 0x8(%r12), %rax
cmpq %rax, %r14
jge 0x2aae
movq 0x10(%r15), %rdi
callq 0x3db0
movq 0x88(%rax), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rax
cmpl $0x7, (%rax,%r14,4)
jne 0x2aa9
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbx,8), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%r14,8)
incq %r14
jmp 0x2a65
incq %rbx
jmp 0x2a58
incq %r13
jmp 0x2a4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/amrsolver.cpp
// Function: main
int main(int argc, char **argv) {


	//reading input
	read_input_file();

	//setting up grid
	myOctree::OctreeGrid();
	amrsolver::adapt_gradient();

	//setting initial condition
	//amrsolver::set_field();
	
	//solving
	amrsolver::multigrid("alpha");
	
	//checking flags
	amrsolver::set_field();

	//writing vtk
	myOctree::create_lists_of_level_nodes();
	myOctree::create_list_of_leaf_nodes();
	myOctree::write_vtk(myOctree::leaf_nodes,"level-4");
	myOctree::write_vtk(myOctree::level_nodes[0],"level-0");
	myOctree::write_vtk(myOctree::level_nodes[1],"level-1");
	myOctree::write_vtk(myOctree::level_nodes[2],"level-2");
	myOctree::write_vtk(myOctree::level_nodes[3],"level-3");
	
	//writing output file
	write_output_file();

	cerr << "\n" << "Finishing" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
callq 0xb56a
callq 0x3623
callq 0x2ac7
leaq 0xc4e4(%rip), %rsi      # 0xf038
leaq -0xd0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d10
leaq -0xd0(%rbp), %rdi
callq 0xe1ec
leaq -0xd0(%rbp), %rdi
callq 0x2100
callq 0x2a06
callq 0x2e8e
callq 0x2dec
leaq 0xc4ac(%rip), %rsi      # 0xf03e
leaq -0xb0(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d10
leaq 0x10667(%rip), %rdi     # 0x13210
leaq -0xb0(%rbp), %rsi
callq 0x8ed1
leaq -0xb0(%rbp), %rdi
callq 0x2100
leaq 0xc47e(%rip), %rsi      # 0xf046
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d10
leaq 0x10661(%rip), %rbx     # 0x13240
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x8ed1
leaq -0x90(%rbp), %rdi
callq 0x2100
leaq 0xc44d(%rip), %rsi      # 0xf04e
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d10
leaq 0x18(%rbx), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8ed1
leaq -0x70(%rbp), %rdi
callq 0x2100
leaq 0xc42b(%rip), %rsi      # 0xf056
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d10
leaq 0x30(%rbx), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8ed1
leaq -0x50(%rbp), %rdi
callq 0x2100
leaq 0xc409(%rip), %rsi      # 0xf05e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2d10
addq $0x48, %rbx
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x8ed1
leaq -0x30(%rbp), %rdi
callq 0x2100
callq 0x98ca
movq 0x10369(%rip), %rdi     # 0x12ff0
leaq 0xc6a5(%rip), %rsi      # 0xf333
callq 0x21d0
leaq 0xc3cc(%rip), %rsi      # 0xf066
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x2cfd
jmp 0x2d04
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x2cfd
jmp 0x2d04
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x2cfd
jmp 0x2d04
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x2cfd
jmp 0x2d04
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x2cfd
jmp 0x2d04
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x2100
jmp 0x2d07
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/octreegrid.cpp
// Function: myOctree::create_list_of_leaf_nodes()
void create_list_of_leaf_nodes() {

	leaf_nodes.clear();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10413(%rip), %rbx     # 0x13210
movq %rbx, %rdi
callq 0x3668
leaq 0x103ec(%rip), %r14     # 0x131f8
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x2e32
movq 0x10(%r15), %rdi
callq 0x3d8c
testb %al, %al
je 0x2e0f
leaq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x368a
jmp 0x2e0f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x103da(%rip), %rbx     # 0x13228
movq %rbx, %rdi
callq 0x3668
leaq 0x1039b(%rip), %r14     # 0x131f8
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x2e83
movq 0x10(%r15), %rdi
callq 0x3d9e
testb %al, %al
je 0x2e60
leaq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x368a
jmp 0x2e60
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
leaq 0x10762(%rip), %r15     # 0x13604
leaq 0x10397(%rip), %r14     # 0x13240
cmpl (%r15), %ebx
ja 0x2ec0
movl %ebx, %eax
imulq $0x18, %rax, %rdi
addq %r14, %rdi
callq 0x3668
incl %ebx
jmp 0x2ea9
leaq 0x10331(%rip), %r15     # 0x131f8
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x2ef5
leaq 0x10(%r12), %rbx
movq 0x10(%r12), %rdi
callq 0x3e06
cltq
imulq $0x18, %rax, %rdi
addq %r14, %rdi
movq %rbx, %rsi
callq 0x368a
jmp 0x2eca
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x106ef(%rip), %r14     # 0x13604
leaq 0x10504(%rip), %r12     # 0x13420
movl (%r14), %eax
cmpl %eax, %ebx
ja 0x2f35
movl %ebx, %eax
imulq $0x18, %rax, %rdi
addq %r12, %rdi
callq 0x3668
incl %ebx
jmp 0x2f1c
xorl %r13d, %r13d
leaq 0x102b9(%rip), %r15     # 0x131f8
cmpl %eax, %r13d
ja 0x2fa9
movl %r13d, %eax
imulq $0x18, %rax, %rbx
addq %r12, %rbx
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x2f94
leaq 0x10(%r12), %r14
movq 0x10(%r12), %rdi
callq 0x3e06
cmpl %r13d, %eax
jae 0x2f7a
movq (%r14), %rdi
callq 0x3d8c
testb %al, %al
jne 0x2f87
movq (%r14), %rdi
callq 0x3e06
cmpl %r13d, %eax
jne 0x2f51
movq %rbx, %rdi
movq %r14, %rsi
callq 0x368a
jmp 0x2f51
incl %r13d
leaq 0x10666(%rip), %rax     # 0x13604
movl (%rax), %eax
leaq 0x10479(%rip), %r12     # 0x13420
jmp 0x2f3f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %rbx
movl %edi, %r14d
leaq -0x110(%rbp), %rdi
callq 0x47cc
leaq 0x10217(%rip), %rdi     # 0x131f8
callq 0x369a
movl $0xf8, %edi
callq 0x21e0
movq %rax, %r15
leaq -0x110(%rbp), %rsi
movq %rax, %rdi
callq 0x4620
xorl %eax, %eax
cmpq $0x3, %rax
je 0x3022
movq (%rbx,%rax,8), %rcx
movl (%rcx), %edx
movl %edx, 0x38(%r15,%rax,8)
movl 0x4(%rcx), %ecx
movl %ecx, 0x3c(%r15,%rax,8)
incq %rax
jmp 0x3004
movl %r14d, 0x98(%r15)
leaq -0x110(%rbp), %rdi
callq 0x45f2
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xf8, %esi
movq %r15, %rdi
callq 0x21f0
jmp 0x3058
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x45f2
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edi, %r14d
xorl %r15d, %r15d
leaq 0x100a9(%rip), %r12     # 0x13618
leaq -0x68(%rbp), %rbx
xorl %r13d, %r13d
movq (%r12), %rsi
movq 0x8(%r12), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x35b2
addq %r15, %rsi
movq %rbx, %rdi
callq 0x2270
movl %r14d, %edi
movq %rbx, %rsi
callq 0x6c98
movq %rbx, %rdi
callq 0x2100
incq %r13
addq $0x20, %r15
jmp 0x3576
xorl %r15d, %r15d
leaq 0x10074(%rip), %r12     # 0x13630
leaq -0x48(%rbp), %rbx
xorl %r13d, %r13d
movq (%r12), %rsi
movq 0x8(%r12), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x35ff
addq %r15, %rsi
movq %rbx, %rdi
callq 0x2270
movl %r14d, %edi
movq %rbx, %rsi
callq 0x6c98
movq %rbx, %rdi
callq 0x2100
incq %r13
addq $0x20, %r15
jmp 0x35c3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3610
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf9c2(%rip), %rdi      # 0x12ff0
leaq 0xbcfe(%rip), %rsi      # 0xf333
callq 0x21d0
leaq 0xbb16(%rip), %rsi      # 0xf157
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
callq 0x3276
xorl %edi, %edi
popq %rbp
jmp 0x3551
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
callq 0x2dec
leaq 0xfa19(%rip), %rbx      # 0x13210
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x3823
movq 0x10(%r14), %rdi
callq 0x3e06
cmpl 0xfdf3(%rip), %eax      # 0x13604
jge 0x37fa
movq 0x10(%r14), %rdi
cmpb $0x1, (%rdi)
jne 0x37fa
callq 0x3fd4
jmp 0x37fa
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2dec
leaq 0xf9b6(%rip), %rbx      # 0x131f8
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x38c3
movq 0x10(%r14), %rdi
cmpb $0x1, 0x1(%rdi)
jne 0x38ae
callq 0x3d9e
testb %al, %al
jne 0x38ae
movq 0x10(%r14), %rdi
callq 0x3d8c
testb %al, %al
je 0x38ae
xorl %r15d, %r15d
cmpl $0x2, %r15d
je 0x38b3
xorl %r12d, %r12d
cmpl $0x2, %r12d
je 0x38a9
xorl %r13d, %r13d
cmpl $0x2, %r13d
je 0x38a4
movq 0x10(%r14), %rdi
callq 0x3e5e
movq %rax, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x3e38
incl %r13d
jmp 0x387f
incl %r12d
jmp 0x3876
incl %r15d
jmp 0x386d
movq (%r14), %r14
jmp 0x3845
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d72
movq %rax, %r14
jmp 0x3845
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x2dec
leaq 0xf512(%rip), %r12      # 0x13210
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x3d62
movq 0x10(%r13), %rax
cmpb $0x1, 0x1(%rax)
jne 0x3d01
xorl %ebx, %ebx
cmpl $0x2, %ebx
je 0x3d01
xorl %r14d, %r14d
cmpl $0x2, %r14d
je 0x3d5e
xorl %r15d, %r15d
cmpl $0x2, %r15d
je 0x3d59
movq 0x10(%r13), %rdi
callq 0x3e5e
movq %rax, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x3e12
cmpb $0x0, 0x1(%rax)
jne 0x3d54
movq 0x10(%r13), %rax
movb $0x0, 0x1(%rax)
incl %r15d
jmp 0x3d27
incl %r14d
jmp 0x3d1e
incl %ebx
jmp 0x3d16
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0xe8(%rdi), %rax
testq %rax, %rax
je 0x3ed3
addq $0xa0, %rax
xorl %r8d, %r8d
cmpq $0x2, %r8
je 0x3ecc
movq %rax, %r9
xorl %r10d, %r10d
cmpq $0x2, %r10
je 0x3ec3
movq %r9, %r11
xorl %ebx, %ebx
cmpq $0x2, %rbx
je 0x3eba
cmpq %rdi, (%r11)
jne 0x3eb1
movl %ebx, (%rsi)
movl %r10d, (%rdx)
movl %r8d, (%rcx)
incq %rbx
addq $0x20, %r11
jmp 0x3e9e
incq %r10
addq $0x10, %r9
jmp 0x3e93
incq %r8
addq $0x8, %rax
jmp 0x3e87
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xf116(%rip), %rdi      # 0x12ff0
leaq 0xb2af(%rip), %rsi      # 0xf190
callq 0x21d0
movq %rax, %rdi
callq 0x2110
pushq $0x1
popq %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb $0x1, (%rdi)
cmpq $0x0, 0xe8(%rdi)
je 0x3f88
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x38(%rdi), %r15
pushq $0x8
popq %r12
xorl %eax, %eax
cmpq $0x3, %rax
je 0x3f7a
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0x3f65
cmpq $0x0, (%r14,%r13,2)
jne 0x3f5f
cmpl $0x0, (%r15,%r13)
jne 0x3f5f
movq 0xe8(%rbx), %rax
addq %r12, %rax
movq (%rax,%r13,2), %rdi
cmpb $0x0, (%rdi)
jne 0x3f5f
callq 0x3ef6
addq $0x4, %r13
jmp 0x3f33
movq -0x30(%rbp), %rax
incq %rax
addq $0x10, %r14
addq $0x8, %r15
addq $0x10, %r12
jmp 0x3f26
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rdi), %rcx
movb $0x1, %al
xorl %edx, %edx
xorl %esi, %esi
cmpq $0x3, %rsi
je 0x3fcc
xorl %r8d, %r8d
cmpq $0x2, %r8
je 0x3fc3
movq (%rcx,%r8,8), %r9
testq %r9, %r9
je 0x3fbe
cmpq $0x0, 0xa0(%r9)
movzbl %al, %eax
cmovnel %edx, %eax
incq %r8
jmp 0x3fa1
incq %rsi
addq $0x10, %rcx
jmp 0x3f98
andb $0x1, %al
movb %al, 0x1(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/octree.cpp
// Function: myOctree::Octree::Octree(myOctree::Octree const&)
Octree::Octree(const Octree &obj) {
    
//	std::cerr << " copy constructor of octree is working " << std::endl;

  	x_min = obj.x_min;
    	y_min = obj.y_min;
    	z_min = obj.z_min;
    	x_max = obj.x_max;
    	y_max = obj.y_max;
    	z_max = obj.z_max;
    	x_centre = obj.x_centre;
    	y_centre = obj.y_centre;
    	z_centre = obj.z_centre;
    	level = obj.level;

    	for(int i=0; i<2; i++) {
        	for(int j=0; j<2; j++) {
            		for(int k=0; k<2; k++)
                		children[i][j][k] = obj.children[i][j][k];
        	}
    	}

    	parent = obj.parent;
    	block_data = new Block(*(obj.block_data));
	setToRefine = obj.setToRefine;
	setToCoarsen = obj.setToCoarsen;

	number = obj.number;

	//neighbors
	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			neighbour[m][n] = obj.neighbour[m][n];
		}
	}	
	
	//boundary conditions
	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			bc[m][n] = obj.bc[m][n];
		}
	}	
    	

	nodes.push_back(this);
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x68(%rdi)
movsd 0x78(%rsi), %xmm0
movsd %xmm0, 0x78(%rdi)
movsd 0x88(%rsi), %xmm0
movsd %xmm0, 0x88(%rdi)
movsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x70(%rdi)
movsd 0x80(%rsi), %xmm0
movsd %xmm0, 0x80(%rdi)
movsd 0x90(%rsi), %xmm0
movsd %xmm0, 0x90(%rdi)
movsd 0x50(%rsi), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x58(%rdi)
movsd 0x60(%rsi), %xmm0
movsd %xmm0, 0x60(%rdi)
movl 0xf0(%rsi), %eax
movl %eax, 0xf0(%rdi)
movl $0xa0, %eax
leaq (%rsi,%rax), %rcx
addq %rdi, %rax
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x46fb
movq %rax, %rsi
movq %rcx, %rdi
xorl %r8d, %r8d
cmpq $0x2, %r8
je 0x46ee
xorl %r9d, %r9d
cmpq $0x2, %r9
je 0x46e1
movq (%rdi,%r9,8), %r10
movq %r10, (%rsi,%r9,8)
incq %r9
jmp 0x46ce
incq %r8
addq $0x10, %rdi
addq $0x10, %rsi
jmp 0x46c5
incq %rdx
addq $0x20, %rcx
addq $0x20, %rax
jmp 0x46b6
movq 0xe8(%r14), %rax
movq %rax, 0xe8(%rbx)
movl $0x90, %edi
callq 0x21e0
movq %rax, %r15
movq 0xe0(%r14), %rsi
movq %rax, %rdi
callq 0x582e
movq %r15, 0xe0(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movb 0x1(%r14), %al
movb %al, 0x1(%rbx)
movl 0x98(%r14), %eax
movl %eax, 0x98(%rbx)
leaq 0x8(%r14), %rax
leaq 0x8(%rbx), %rcx
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x4777
xorl %esi, %esi
cmpq $0x2, %rsi
je 0x476a
movq (%rax,%rsi,8), %rdi
movq %rdi, (%rcx,%rsi,8)
incq %rsi
jmp 0x4757
incq %rdx
addq $0x10, %rax
addq $0x10, %rcx
jmp 0x474f
pushq $0x7
popq %rax
cmpq $0xa, %rax
je 0x4795
movl (%r14,%rax,8), %ecx
movl %ecx, (%rbx,%rax,8)
movl 0x4(%r14,%rax,8), %ecx
movl %ecx, 0x4(%rbx,%rax,8)
incq %rax
jmp 0x477a
leaq -0x20(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0xea55(%rip), %rdi      # 0x131f8
callq 0x4a9c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x90, %esi
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/octree.cpp
// Function: myOctree::Octree::Octree(double, double, double, double, double, double, int)
Octree::Octree( double x1, double x2, double y1, double y2, double z1, double z2, int l ) : x_min(x1), x_max(x2), y_min(y1), y_max(y2), z_min(z1), z_max(z2), level(l)   {
//	std::cerr << " parametrized constructor of octree is working " << std::endl;
    
    	for(int i=0; i<2; i++) {
        	for(int j=0; j<2; j++) {
            		for(int k=0; k<2; k++)
                		children[i][j][k] = NULL;
        	}
    	}
    
	parent = NULL;
   	setToRefine = false;
	setToCoarsen = false; 
	
	//neighbors
	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			neighbour[m][n] = NULL;
		}
	}	
   
	//boundary conditions
	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			bc[m][n] = NONE;
		}
	}	

	number = 0;
 
    	x_centre = (x_min + x_max ) / 2.0;
    	y_centre = (y_min + y_max ) / 2.0;
    	z_centre = (z_min + z_max ) / 2.0;
    
    
    	//creating block to assign it to the data
    	Block new_block(x_min, x_max, y_min, y_max, z_min, z_max);
    	block_data = new Block(new_block);
    
    	nodes.push_back(this);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x68(%rdi)
movsd %xmm1, 0x70(%rdi)
movsd %xmm2, 0x78(%rdi)
movsd %xmm3, 0x80(%rdi)
movsd %xmm4, 0x88(%rdi)
movsd %xmm5, 0x90(%rdi)
movl %esi, 0xf0(%rdi)
leaq 0xa0(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x4848
movq %rax, %rdx
xorl %esi, %esi
cmpq $0x2, %rsi
je 0x483f
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x4836
andq $0x0, (%rdx,%rdi,8)
incq %rdi
jmp 0x4826
incq %rsi
addq $0x10, %rdx
jmp 0x481e
incq %rcx
addq $0x20, %rax
jmp 0x4813
andq $0x0, 0xe8(%rbx)
andw $0x0, (%rbx)
leaq 0x8(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x487b
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x4872
andq $0x0, (%rax,%rdx,8)
incq %rdx
jmp 0x4862
incq %rcx
addq $0x10, %rax
jmp 0x485a
pushq $0x7
popq %rax
cmpq $0xa, %rax
je 0x488e
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x487e
andl $0x0, 0x98(%rbx)
movapd %xmm0, %xmm6
addsd %xmm1, %xmm6
movsd 0xa8e3(%rip), %xmm7     # 0xf188
mulsd %xmm7, %xmm6
movsd %xmm6, 0x50(%rbx)
movapd %xmm2, %xmm6
addsd %xmm3, %xmm6
mulsd %xmm7, %xmm6
movsd %xmm6, 0x58(%rbx)
movapd %xmm4, %xmm6
addsd %xmm5, %xmm6
mulsd %xmm7, %xmm6
movsd %xmm6, 0x60(%rbx)
leaq -0xa8(%rbp), %rdi
callq 0x4b18
movl $0x90, %edi
callq 0x21e0
movq %rax, %r14
leaq -0xa8(%rbp), %rsi
movq %rax, %rdi
callq 0x582e
movq %r14, 0xe0(%rbx)
leaq -0x18(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0xe8eb(%rip), %rdi      # 0x131f8
callq 0x4a9c
leaq -0xa8(%rbp), %rdi
callq 0x5b34
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x493e
movq %rax, %rbx
movl $0x90, %esi
movq %r14, %rdi
callq 0x21f0
jmp 0x4941
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x5b34
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/octree.cpp
// Function: myOctree::Octree::Octree()
Octree::Octree() {
//	std::cerr << " default constructor of octree is working " << std::endl;
    
    for(int i=0; i<2; i++) {
        for(int j=0; j<2; j++) {
            for(int k=0; k<2; k++)
                children[i][j][k] = NULL;
        }
    }
    
 	parent = NULL;
	setToRefine = false;
	setToCoarsen = false;   

	//neighbors
	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			neighbour[m][n] = NULL;
		}
	}	
	
	x_centre = 0.0;
	y_centre = 0.0;
	z_centre = 0.0;
	x_min = 0.0;
	y_min = 0.0;
	z_min = 0.0;
	x_max = 0.0;
	y_max = 0.0;
	z_max = 0.0;

	level = 0;

	//boundary conditions
	for(int m=0;m<3;m++) {
		for(int n=0;n<2;n++) {
			bc[m][n] = NONE;
		}
	}	

	number = 0;

    //creating block to assign it to the data
    Block new_block;
    block_data = new Block(new_block);
    
    nodes.push_back(this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x49a5
movq %rax, %rdx
xorl %esi, %esi
cmpq $0x2, %rsi
je 0x499c
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x4993
andq $0x0, (%rdx,%rdi,8)
incq %rdi
jmp 0x4983
incq %rsi
addq $0x10, %rdx
jmp 0x497b
incq %rcx
addq $0x20, %rax
jmp 0x4970
andq $0x0, 0xe8(%rbx)
andw $0x0, (%rbx)
leaq 0x8(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x49d8
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x49cf
andq $0x0, (%rax,%rdx,8)
incq %rdx
jmp 0x49bf
incq %rcx
addq $0x10, %rax
jmp 0x49b7
andl $0x0, 0xf0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
andq $0x0, 0x90(%rbx)
pushq $0x7
popq %rax
cmpq $0xa, %rax
je 0x4a10
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x4a00
andl $0x0, 0x98(%rbx)
leaq -0xa8(%rbp), %rdi
callq 0x5360
movl $0x90, %edi
callq 0x21e0
movq %rax, %r14
leaq -0xa8(%rbp), %rsi
movq %rax, %rdi
callq 0x582e
movq %r14, 0xe0(%rbx)
leaq -0x18(%rbp), %rsi
movq %rbx, (%rsi)
leaq 0xe7a4(%rip), %rdi      # 0x131f8
callq 0x4a9c
leaq -0xa8(%rbp), %rdi
callq 0x5b34
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4a85
movq %rax, %rbx
movl $0x90, %esi
movq %r14, %rdi
callq 0x21f0
jmp 0x4a88
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x5b34
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/block.cpp
// Function: myOctree::Block::~Block()
Block::~Block() {
  //		std::cerr << "destructor of block is working" << std::endl;

        delete mesh;
	delete field;

	for (int i = 0; i < scalar_fields.size(); ++i)
                        delete scalarfields[i];
   	
	delete scalarfields;

	for (int i = 0; i < vector_fields.size(); ++i)
                        delete vectorfields[i];
   	
	delete vectorfields;


	for (int i = 0; i < (iNx+2*pad); ++i) {
		for (int j = 0; j < (iNy+2*pad); ++j)
	      		delete [] flag[i][j];
	 
		delete [] flag[i];
	}
	
	delete [] flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x5b52
movq %r14, %rdi
callq 0x61cc
movl $0x90, %esi
movq %r14, %rdi
callq 0x21f0
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x5b70
movq %r15, %rdi
callq 0x65b0
pushq $0x50
popq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x21f0
xorl %r12d, %r12d
movq 0xda97(%rip), %rax      # 0x13620
subq 0xda88(%rip), %rax      # 0x13618
sarq $0x5, %rax
movq 0x10(%rbx), %rdi
cmpq %r12, %rax
jbe 0x5bbe
movq (%rdi,%r12,8), %r15
testq %r15, %r15
je 0x5bae
movq %r15, %rdi
callq 0x65b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x21f0
incq %r12
jmp 0x5b82
pushq $0x8
popq %rsi
callq 0x21f0
xorl %r15d, %r15d
movq 0xda68(%rip), %rax      # 0x13638
subq 0xda59(%rip), %rax      # 0x13630
sarq $0x5, %rax
movq 0x18(%rbx), %rdi
cmpq %r15, %rax
jbe 0x5c07
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x5bf5
movq %r14, %rdi
callq 0x61cc
movl $0x90, %esi
movq %r14, %rdi
callq 0x21f0
incq %r15
jmp 0x5bc9
pushq $0x8
popq %rsi
callq 0x21f0
xorl %r14d, %r14d
movl 0xd5b8(%rip), %eax      # 0x131d0
movslq 0xda29(%rip), %rcx      # 0x13648
movslq %eax, %rdx
leaq (%rcx,%rdx,2), %rcx
cmpq %rcx, %r14
jge 0x5c7e
movl 0xda1b(%rip), %ecx      # 0x1364c
xorl %r15d, %r15d
leal (%rcx,%rax,2), %edx
movslq %edx, %rdx
movq 0x88(%rbx), %rsi
movq (%rsi,%r14,8), %rdi
cmpq %rdx, %r15
jge 0x5c69
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0x5c64
callq 0x2250
movl 0xd9ee(%rip), %ecx      # 0x1364c
movl 0xd56c(%rip), %eax      # 0x131d0
incq %r15
jmp 0x5c34
testq %rdi, %rdi
je 0x5c79
callq 0x2250
movl 0xd557(%rip), %eax      # 0x131d0
incq %r14
jmp 0x5c18
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5c97
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/vecfield.cpp
// Function: myOctree::VecField::VecField(int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
VecField::VecField( 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 vecfield is working" << std::endl; 
                
        N = Nx*Ny*Nz;
        x = new double** [Nx];
        y = new double** [Nx];
        z = new double** [Nx];
        for(int i=0;i<Nx;i++) {
                x[i] = new double* [Ny];
                y[i] = new double* [Ny];
                z[i] = new double* [Ny];
                for(int j=0;j<Ny;j++) {
                        x[i][j] = new double [Nz];
                        y[i][j] = new double [Nz];
                        z[i][j] = new double [Nz];
                }       
        }

	set_field(0.0);
       
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
movq %r8, %rsi
callq 0x2270
movslq (%r14), %rdx
movslq 0x4(%r14), %r12
movl %r12d, %eax
imull %edx, %eax
movslq 0x8(%r14), %rbx
movl %ebx, %ecx
imull %eax, %ecx
leaq (,%rdx,8), %r15
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
movl %ecx, 0xc(%r14)
pushq $-0x1
popq %r13
cmovsq %r13, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x18(%r14)
movq %r15, %rdi
callq 0x2030
movq %r12, %rcx
shlq $0x3, %rcx
movq %r12, %rdx
movq %rbx, %r12
shlq $0x3, %r12
testl %ebx, %ebx
cmovsq %r13, %r12
movq %r13, %rsi
xorl %r13d, %r13d
testl %edx, %edx
cmovsq %rsi, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, 0x20(%r14)
movl $0x0, %ebx
cmovgl %edx, %ebx
movq -0x30(%rbp), %rcx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movq %rax, -0x30(%rbp)
cmpq -0x30(%rbp), %r13
je 0x5e91
movq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq %r15, %rdi
callq 0x2030
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq %r15, %rdi
callq 0x2030
movq 0x20(%r14), %rcx
movq %rax, (%rcx,%r13,8)
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x5e89
movq %r12, %rdi
callq 0x2030
movq 0x10(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
movq %r12, %rdi
callq 0x2030
movq 0x18(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
movq %r12, %rdi
callq 0x2030
movq 0x20(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x5e43
incq %r13
jmp 0x5e02
xorps %xmm0, %xmm0
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5ec2
jmp 0x5eae
jmp 0x5eae
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
testl %eax, %eax
cmovlel %edx, %eax
xorl %esi, %esi
cmpq %rax, %rsi
je 0x5f43
movl 0x8(%rdi), %r8d
testl %r8d, %r8d
cmovlel %edx, %r8d
xorl %r9d, %r9d
cmpq %rcx, %r9
je 0x5f3e
movq 0x10(%rdi), %r10
movq 0x18(%rdi), %r11
movq 0x20(%rdi), %rbx
xorl %r14d, %r14d
cmpq %r14, %r8
je 0x5f39
movq (%r10,%rsi,8), %r15
movq (%r15,%r9,8), %r15
movsd %xmm0, (%r15,%r14,8)
movq (%r11,%rsi,8), %r15
movq (%r15,%r9,8), %r15
movsd %xmm0, (%r15,%r14,8)
movq (%rbx,%rsi,8), %r15
movq (%r15,%r9,8), %r15
movsd %xmm0, (%r15,%r14,8)
incq %r14
jmp 0x5f05
incq %r9
jmp 0x5ef1
incq %rsi
jmp 0x5ede
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suhasjains[P]AMR-Solver/src/vecfield.cpp
// Function: myOctree::VecField::VecField()
VecField::VecField() {
 //             std::cerr << "default constructor of vecfield is working" << std::endl;
 
        Nx = 0;
        Ny = 0;
        Nz = 0;
        N = Nx*Ny*Nz;
        x = new double** [Nx];
        y = new double** [Nx];
        z = new double** [Nx];
        for(int i=0;i<Nx;i++) {
                x[i] = new double* [Ny];
                y[i] = new double* [Ny];
                z[i] = new double* [Ny];
                for(int j=0;j<Ny;j++) {
                        x[i][j] = new double [Nz];
                        y[i][j] = new double [Nz];
                        z[i][j] = new double [Nz];
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movb $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edi, %edi
callq 0x2030
movq %rax, 0x10(%rbx)
xorl %edi, %edi
callq 0x2030
movq %rax, 0x18(%rbx)
xorl %edi, %edi
callq 0x2030
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x6271
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
cmpq %rax, %r15
jge 0x623b
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0x620a
callq 0x2250
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x6220
callq 0x2250
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x6236
callq 0x2250
incq %r15
jmp 0x61eb
testq %rdi, %rdi
je 0x6245
callq 0x2250
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6257
callq 0x2250
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6269
callq 0x2250
incq %r14
jmp 0x61dc
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x627f
callq 0x2250
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x628d
callq 0x2250
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x629b
callq 0x2250
addq $0x28, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
movq %r8, %rsi
callq 0x2270
movslq (%r14), %rdx
movslq 0x4(%r14), %r15
movl %r15d, %eax
imull %edx, %eax
movslq 0x8(%r14), %rbx
movl %ebx, %ecx
imull %eax, %ecx
leaq (,%rdx,8), %rdi
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
movl %ecx, 0xc(%r14)
pushq $-0x1
popq %r13
cmovsq %r13, %rdi
callq 0x2030
movq %r15, %rcx
shlq $0x3, %rcx
movq %rbx, %r12
shlq $0x3, %r12
testl %ebx, %ebx
cmovsq %r13, %r12
movq %r13, %rdx
xorl %r13d, %r13d
testl %r15d, %r15d
cmovsq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, 0x10(%r14)
movl $0x0, %ebx
cmovgl %r15d, %ebx
movq -0x30(%rbp), %rcx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movq %rax, -0x30(%rbp)
cmpq -0x30(%rbp), %r13
je 0x6397
movq -0x40(%rbp), %rdi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r13,8)
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x6392
movq %r12, %rdi
callq 0x2030
movq 0x10(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x6374
incq %r13
jmp 0x635a
xorps %xmm0, %xmm0
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63c8
jmp 0x63b4
jmp 0x63b4
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
testl %eax, %eax
cmovlel %edx, %eax
xorl %esi, %esi
cmpq %rax, %rsi
je 0x6421
movl 0x8(%rdi), %r8d
testl %r8d, %r8d
cmovlel %edx, %r8d
xorl %r9d, %r9d
cmpq %rcx, %r9
je 0x641c
movq 0x10(%rdi), %r10
xorl %r11d, %r11d
cmpq %r11, %r8
je 0x6417
movq (%r10,%rsi,8), %rbx
movq (%rbx,%r9,8), %rbx
movsd %xmm0, (%rbx,%r11,8)
incq %r11
jmp 0x63ff
incq %r9
jmp 0x63f3
incq %rsi
jmp 0x63e0
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %r14
movb $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %edi, %edi
callq 0x2030
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2320