LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: TextDisplay::TextDisplay(std::vector<int, std::allocator<int>>)
TextDisplay::TextDisplay(std::vector<int> gridSize):
    gridSize {gridSize}
    {
        for (int i = 0; i < gridSize[0]; ++i) {
            theDisplay.push_back(std::vector<char>());
            for (int j = 0; j < gridSize[1]; ++j) {
                theDisplay[i].push_back(' ');
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3d400
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq 0x2a14d(%rip), %rax     # 0x66ce0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x19880
jmp 0x3cba5
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
callq 0x3d420
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x68(%rbp)
callq 0x6250
jmp 0x3cbc9
movq -0x60(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq %rdi, -0x78(%rbp)
callq 0x2db80
movq -0x60(%rbp), %rax
movl $0x1, 0x220(%rax)
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x7c(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq %rax, %rcx
movl -0x7c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3cd0b
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3d470
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x3d440
jmp 0x3cc56
leaq -0x40(%rbp), %rdi
callq 0x22570
movl $0x0, -0x44(%rbp)
movq -0x58(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x94(%rbp)
movl $0x1, %esi
callq 0x19850
movq %rax, %rcx
movl -0x94(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3ccfb
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
movslq -0x20(%rbp), %rsi
callq 0x3d490
movq %rax, %rdi
movb $0x20, -0x45(%rbp)
leaq -0x45(%rbp), %rsi
callq 0x3d4b0
jmp 0x3ccad
jmp 0x3ccaf
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3cc66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3cd38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3cd26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x22570
jmp 0x3cd14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3cd14
jmp 0x3ccfd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3cbf2
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1a1b0
movq -0x68(%rbp), %rdi
callq 0x6270
movq -0x70(%rbp), %rdi
callq 0x223f0
movq -0x50(%rbp), %rdi
callq 0x19640
movq -0x60(%rbp), %rdi
callq 0x3b6c0
movq -0x18(%rbp), %rdi
callq 0x6550
nopw (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: TextDisplay::setGridSize(std::vector<int, std::allocator<int>>)
void TextDisplay::setGridSize(std::vector<int> size) {
    gridSize = size;
    theDisplay = std::vector<std::vector<char>>();
    for (int i = 0; i < gridSize[0]; ++i) {
        theDisplay.push_back(std::vector<char>());
        for (int j = 0; j < gridSize[1]; ++j) {
            theDisplay[i].push_back(' ');
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0x2d7f0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x61c0
leaq -0x28(%rbp), %rdi
callq 0x3d420
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x3d4e0
leaq -0x28(%rbp), %rdi
callq 0x223f0
movl $0x0, -0x2c(%rbp)
movq -0x70(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x74(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3ce9b
movq -0x70(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3d470
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x3d440
jmp 0x3ce10
leaq -0x50(%rbp), %rdi
callq 0x22570
movl $0x0, -0x60(%rbp)
movq -0x70(%rbp), %rdi
movl -0x60(%rbp), %eax
movl %eax, -0x8c(%rbp)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x19850
movq %rax, %rcx
movl -0x8c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3ce8b
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3d490
movq %rax, %rdi
movb $0x20, -0x61(%rbp)
leaq -0x61(%rbp), %rsi
callq 0x3d4b0
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x3ce20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x22570
jmp 0x3cea4
jmp 0x3ce8d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3cdae
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6550
nopl (%rax)
// File: XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: TextDisplay::notify(Subject&)
void TextDisplay::notify(Subject &notifier) {
    Info i = notifier.getInfo();
    if (i.isCellInfo) {
        info.coordinates = i.coordinates;
        info.displayChar = i.displayChar;
        theDisplay[info.coordinates[0]][info.coordinates[1]] = info.displayChar;
    }
    else {

        info.lastAction = i.lastAction;
        info.race = i.race;
        info.gold = i.gold;
        info.HP = i.HP;
        info.attackValue = i.attackValue;
        info.defenceValue = i.defenceValue;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
leaq -0x70(%rbp), %rdi
callq *(%rax)
testb $0x1, -0x18(%rbp)
je 0x3cf9e
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x2d7f0
jmp 0x3cefe
movq -0x88(%rbp), %rdi
movb -0x40(%rbp), %al
movb %al, 0x1f0(%rdi)
movb 0x1f0(%rdi), %al
movb %al, -0x89(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0xa0(%rbp)
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq -0xa0(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3d490
movq -0x88(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x18, %rdi
movl $0x1, %esi
callq 0x19850
movq -0x98(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3d510
movb -0x89(%rbp), %cl
movb %cl, (%rax)
jmp 0x3cfeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1a1b0
jmp 0x3cffd
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x6050
jmp 0x3cfb7
movq -0x88(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, 0x1c0(%rax)
movl -0x6c(%rbp), %ecx
movl %ecx, 0x1c4(%rax)
movl -0x68(%rbp), %ecx
movl %ecx, 0x1c8(%rax)
movl -0x64(%rbp), %ecx
movl %ecx, 0x1cc(%rax)
movl -0x60(%rbp), %ecx
movl %ecx, 0x1d0(%rax)
leaq -0x70(%rbp), %rdi
callq 0x1a1b0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Floor/Floor.cc
// Function: Floor::Floor(TextDisplay*)
Floor::Floor(TextDisplay* td):
    theFloor {std::vector<std::vector<std::shared_ptr<Cell>>>()},
    theDisplay {td},
    floorDimensions {std::vector<int>()},
    floorNumber {1}
    {
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x61c0
movq -0x18(%rbp), %rdi
callq 0x40610
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x61c0
movq -0x20(%rbp), %rdi
callq 0x19550
movq -0x18(%rbp), %rax
movl $0x1, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Floor/Floor.cc
// Function: Floor::clearFloor()
void Floor::clearFloor() {
    for (auto &row: theFloor) {
        for (auto &c: row) {
            CellType type = c->getCellType();
            std::vector<int> coords = c->getCoords();
//LOOK BACK
            c = std::make_shared<Cell>();
            c->setCoords(coords);
            c->setCellType(type);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40650
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40680
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x406b0
testb $0x1, %al
jne 0x3f527
jmp 0x3f684
leaq -0x18(%rbp), %rdi
callq 0x406f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a400
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a430
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1a460
testb $0x1, %al
jne 0x3f56c
jmp 0x3f674
leaq -0x38(%rbp), %rdi
callq 0x1a4a0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x19df0
movq %rax, %rdi
callq 0x2cc40
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x19df0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x2cbb0
leaq -0x78(%rbp), %rdi
callq 0x40710
jmp 0x3f5ad
movq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x19970
movq -0xb0(%rbp), %rdi
callq 0x199a0
movq -0x48(%rbp), %rdi
callq 0x19df0
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x19880
jmp 0x3f5ef
movq -0xa8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2c820
jmp 0x3f604
leaq -0xa0(%rbp), %rdi
callq 0x19640
movq -0x48(%rbp), %rdi
callq 0x19df0
movq %rax, %rdi
movl -0x4c(%rbp), %esi
callq 0x2c7f0
jmp 0x3f626
leaq -0x68(%rbp), %rdi
callq 0x19640
leaq -0x38(%rbp), %rdi
callq 0x1a4e0
jmp 0x3f556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3f669
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x19640
leaq -0x68(%rbp), %rdi
callq 0x19640
jmp 0x3f68d
jmp 0x3f676
leaq -0x18(%rbp), %rdi
callq 0x40780
jmp 0x3f511
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Floor/Floor.cc
// Function: Floor::getStairCoords()
vector<int> Floor::getStairCoords() {
    for (int i = 0; i < floorDimensions[0]; ++i) {
        for (int j = 0; j < floorDimensions[1]; ++j) {
			shared_ptr<Cell> tempCell = theFloor[i][j];
			if (tempCell && tempCell->getCellType() == CellType::Stairs) {
				return vector<int>{i,j};
			}
        }
    }
	throw 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x74(%rbp)
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3f877
movl $0x0, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x78(%rbp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x19850
movq %rax, %rcx
movl -0x78(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3f867
movq -0x60(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x40630
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2da40
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x19e60
leaq -0x28(%rbp), %rdi
callq 0x1a4c0
testb $0x1, %al
jne 0x3f796
jmp 0x3f831
leaq -0x28(%rbp), %rdi
callq 0x19df0
movq %rax, %rdi
callq 0x2cc40
movl %eax, -0x7c(%rbp)
jmp 0x3f7ac
movl -0x7c(%rbp), %eax
cmpl $0x4, %eax
jne 0x3f831
movl -0x14(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x2, -0x40(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x19570
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x19590
jmp 0x3f7fa
leaq -0x51(%rbp), %rdi
callq 0x196a0
movl $0x1, -0x58(%rbp)
jmp 0x3f838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x3f85c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x196a0
jmp 0x3f85c
movl $0x0, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x199a0
movl -0x58(%rbp), %eax
testl %eax, %eax
je 0x3f84c
jmp 0x3f84a
jmp 0x3f89a
jmp 0x3f84e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f739
leaq -0x28(%rbp), %rdi
callq 0x199a0
jmp 0x3f8a7
jmp 0x3f869
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f70d
movl $0x4, %edi
callq 0x61a0
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x276df(%rip), %rsi     # 0x66f70
xorl %eax, %eax
movl %eax, %edx
callq 0x6520
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6550
// File: ArashPartow[P]exprtk-extras/exprtk_import_packages.cpp
// Function: import_packages<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t parameters) override
   {
      const string_t package(parameters[0]);

      const auto itr = package_map_.find(exprtk::to_str(package));

      if (package_map_.end() == itr)
      {
         return T(0);
      }

      return itr->second(symbol_table_) ? T(1) : T(0);
   }

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x78(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x122d90
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x122fa0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
addq $0x50, %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1230b0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1352d0
movq %rax, 0x30(%rsp)
jmp 0x12269c
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x114858
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
callq 0x135300
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x12f550
testb $0x1, %al
jne 0x1226d8
jmp 0x122700
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0x122753
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x114858
jmp 0x122764
leaq 0x70(%rsp), %rdi
callq 0x135330
movq %rax, %rdi
movq 0x10(%rsp), %rax
addq $0x20, %rdi
movq 0x48(%rax), %rsi
callq 0x135350
movsd 0x3358e1(%rip), %xmm0   # 0x458008
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x122744
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x1144e0
nop
// File: ConsoleTVs[P]VirtualMachine/src/program.cpp
// Function: VM::Program::debug()
void Program::debug()
{
    for (uint32_t i = 0; i < this->code.size(); i++) {
        if (this->code[i] == OP_CONSTANT) {
            printf("%s ", CodeString[this->code[i++]].c_str());
            printf("%s\n", this->constants[this->code[i]]->to_string().c_str());
        } else printf("%s\n", CodeString[this->code[i]].c_str());
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x5c(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x5200
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x54e1
movq 0x20(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x51e0
cmpl $0x0, (%rax)
jne 0x5499
movq 0x20(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
movl %esi, %eax
incl %eax
movl %eax, 0x5c(%rsp)
callq 0x51e0
movl (%rax), %eax
shlq $0x5, %rax
leaq 0x4f53(%rip), %rdi      # 0xa350
addq %rax, %rdi
callq 0x20a0
movq %rax, %rsi
leaq 0x1d4d(%rip), %rdi      # 0x715c
xorl %eax, %eax
movb %al, 0x17(%rsp)
callq 0x2040
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, (%rsp)
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x51e0
movq (%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x5290
movq (%rax), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6420
movq 0x8(%rsp), %rdi
callq 0x20a0
movq %rax, %rsi
movb 0x17(%rsp), %al
leaq 0x1ca2(%rip), %rdi      # 0x710e
callq 0x2040
jmp 0x5473
leaq 0x38(%rsp), %rdi
callq 0x20e0
jmp 0x54cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x20e0
jmp 0x54e6
movq 0x20(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x51e0
movl (%rax), %eax
leaq 0x4e9e(%rip), %rdi      # 0xa350
shlq $0x5, %rax
addq %rax, %rdi
callq 0x20a0
movq %rax, %rsi
leaq 0x1c46(%rip), %rdi      # 0x710e
movb $0x0, %al
callq 0x2040
jmp 0x54d1
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x539b
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2260
// File: ConsoleTVs[P]VirtualMachine/src/values.cpp
// Function: VM::Value::to_float()
float Value::to_float()
{
    switch (this->type) {
        case VALUE_INTEGER: { return (float) this->ivalue; }
        case VALUE_FLOAT: { return (float) this->fvalue; }
        case VALUE_BOOLEAN: { return this->bvalue ? 1 : 0; }
        case VALUE_STRING: { return (float) this->svalue->length(); }
        case VALUE_LIST: { return (float) this->lvalue->size(); }
        default: { printf("Error converting value to int.\n"); }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movzbl (%rax), %eax
movq %rax, 0x20(%rsp)
subq $0x4, %rax
ja 0x6402
movq 0x20(%rsp), %rax
leaq 0xe7b(%rip), %rcx       # 0x717c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x6412
movq 0x18(%rsp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x6412
movq 0x18(%rsp), %rax
movb 0x8(%rax), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x6412
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x10(%rsp)
testq %rax, %rax
movss %xmm0, 0x14(%rsp)
js 0x639f
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x6412
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x52b0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x8(%rsp)
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
js 0x63f4
movss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x6412
leaq 0xd9b(%rip), %rdi       # 0x71a4
movb $0x0, %al
callq 0x2040
ud2
movss 0x34(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: nandakishoremmn2[P]multigrid/main.cpp
// Function: main
int main (int argc, char *argv[]) 
{
	int *input = get_input(argc, argv);

	MultiGridSolver solver(input);
	solver_ptr = &solver;

	signal(SIGINT, signalHandler);

	solver.solve(1e-9);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2b80
movq -0x68(%rbp), %rax
movq %rax, 0x6dce(%rip)      # 0x8100
leaq 0x237(%rip), %rsi       # 0x1570
movl $0x2, %edi
callq 0x1100
movq -0x68(%rbp), %rdi
movsd 0x3cb9(%rip), %xmm0     # 0x5008
callq 0x2d30
jmp 0x1356
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2ce0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2ce0
movq -0x58(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::MultiGrid(int, int, float, int)
MultiGrid::MultiGrid(int grid_density, int no_of_child_grids, float wu, int lvl)
{
	n = pow(2, grid_density) + 1;

	WU = wu;
	level = lvl;

	h = pow(.5, grid_density);
	h2 = h*h;

	// Allocate memory for the grid
	v = initialise();
	f = initialise();
	temp = initialise();

	// Initialise the coarser child grids
	grid2 = ( no_of_child_grids > 0 ) ? new MultiGrid(grid_density-1, no_of_child_grids-1, WU/4.0, level+1) : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x3b39(%rip), %xmm0     # 0x50f8
callq 0x1180
movq -0x40(%rbp), %rax
movsd 0x3b20(%rip), %xmm1     # 0x50f0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x10(%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x38(%rax)
cvtsi2ssl -0x18(%rbp), %xmm0
movss %xmm0, 0x3c(%rax)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x3aec(%rip), %xmm0     # 0x50e8
callq 0x1180
movq -0x40(%rbp), %rdi
movsd %xmm0, 0x18(%rdi)
movsd 0x18(%rdi), %xmm0
mulsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x20(%rdi)
callq 0x1700
movq -0x40(%rbp), %rdi
movq %rax, 0x28(%rdi)
callq 0x1700
movq -0x40(%rbp), %rdi
movq %rax, 0x30(%rdi)
callq 0x1700
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
movb $0x0, -0x21(%rbp)
cmpl $0x0, %eax
jle 0x16b8
movl $0x40, %edi
callq 0x10d0
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl -0xc(%rbp), %esi
decl %esi
movl -0x10(%rbp), %edx
decl %edx
movss 0x38(%rax), %xmm0
movss 0x3c(%rax), %xmm1
cvtss2sd %xmm0, %xmm0
movsd 0x3a71(%rip), %xmm2     # 0x5100
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0x3a79(%rip), %xmm2     # 0x5118
addss %xmm2, %xmm1
cvttss2si %xmm1, %ecx
callq 0x1590
jmp 0x16ae
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x16c0
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x16c0
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x16e5
jmp 0x16f3
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0x10e0
jmp 0x16f5
movq -0x30(%rbp), %rdi
callq 0x1190
nop
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::initialise()
real **MultiGrid::initialise()
{
	real **var = new real*[n];
	for (int i = 0; i < n; ++i)
	{
		var[i] = new real[n];
	}

	for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			var[i][j] = 0;
		}
	}
	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq 0x10(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1793
movq -0x28(%rbp), %rax
movslq 0x10(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1744
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x17e9
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x17dc
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17ad
jmp 0x17de
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x179a
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::~MultiGrid()
MultiGrid::~MultiGrid()
{
	// Free memory of variables
	deallocate(v);
	deallocate(f);
	deallocate(temp);

	// Destroy child grids
	delete grid2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x28(%rdi), %rsi
callq 0x1880
jmp 0x181f
movq -0x10(%rbp), %rdi
movq 0x30(%rdi), %rsi
callq 0x1880
jmp 0x182e
movq -0x10(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x1880
jmp 0x183d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1865
movq -0x18(%rbp), %rdi
callq 0x1800
movq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2b70
nopw %cs:(%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::norm2(double**)
real MultiGrid::norm2(real **data)
{
	// L-squared norm
	real norm2val = 0;
	for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			norm2val += data[i][j]*data[i][j]*h2;
		}
	}

	return sqrt(norm2val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1a33
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x1a26
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x20(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x20(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movsd 0x20(%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x19ca
jmp 0x1a28
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19b7
movsd -0x18(%rbp), %xmm0
callq 0x10a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::relax(int)
GridData MultiGrid::relax(int vn)
{
	for (int k = 0; k < vn; ++k)
	{
		relax_once_rb();
	}

	calc_res_to_temp();

	GridData data = {
		norm2(temp),
		vn*WU,
		vn,
		get_level()
	};

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1fe2
movq -0x18(%rbp), %rdi
callq 0x1b70
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fc6
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x1990
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
cvtsi2ssl -0xc(%rbp), %xmm0
mulss 0x38(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
callq 0x2210
movq -0x28(%rbp), %rcx
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %edx, 0x14(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::calc_res_to_temp()
void MultiGrid::calc_res_to_temp()
{
	for (int i = 1; i < n-1; ++i)
	{
		for (int j = 1; j < n-1; ++j)
		{
			// r = f - Av
			temp[i][j] = f[i][j] - ( 4*v[i][j] - ( v[i+1][j] + v[i-1][j] + v[i][j+1] + v[i][j-1] ) )/h2;
		}
	}

	// Set residual value at boundary to zero
	for (int i = 0; i < n; ++i)
	{
		temp[0][i] = temp[i][0] = temp[n-1][i] = temp[i][n-1] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2181
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2171
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movq 0x28(%rax), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movq 0x28(%rax), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
addsd (%rcx,%rdx,8), %xmm2
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
addsd (%rcx,%rdx,8), %xmm2
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
addsd (%rcx,%rdx,8), %xmm2
movq %xmm2, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm2
movsd 0x2fcb(%rip), %xmm3     # 0x5108
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd 0x20(%rax), %xmm1
subsd %xmm1, %xmm0
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2073
jmp 0x2173
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2057
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x2203
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x10(%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movl 0x10(%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x14(%rbp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx)
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2188
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::apply_boundary_conditions()
void MultiGrid::apply_boundary_conditions()
{
	for (int i = 0; i < n; ++i)
	{
		v[0][i] = v[i][0] = (real)i*i*h2;
		// v[0][i] = (real)i*i*h2;
		v[n-1][i] = v[i][n-1] = 1.0 - (real)i*i*h2;
		// v[n-1][i] = 1.0 - (real)i*i*h2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x10(%rcx), %eax
jge 0x27fa
movq -0x18(%rbp), %rcx
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd 0x20(%rcx), %xmm0
movq 0x28(%rcx), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movsd %xmm0, (%rax)
movq 0x28(%rcx), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rdx
movsd %xmm0, (%rax,%rdx,8)
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x20(%rcx), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x293c(%rip), %xmm1     # 0x50f0
addsd %xmm1, %xmm0
movq 0x28(%rcx), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl 0x10(%rcx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd %xmm0, (%rax,%rdx,8)
movq 0x28(%rcx), %rax
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2737
popq %rbp
retq
nopl (%rax)
// File: nandakishoremmn2[P]multigrid/multigrid.cpp
// Function: MultiGrid::save_grid(char*)
void MultiGrid::save_grid(char *filename)
{
	std::ofstream outfile(filename);
	for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			outfile<<v[i][j]<<" ";
		}
		outfile<<"\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x10f0
movl $0x0, -0x214(%rbp)
movq -0x230(%rbp), %rcx
movl -0x214(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x2af9
movl $0x0, -0x218(%rbp)
movq -0x230(%rbp), %rcx
movl -0x218(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x2ace
movq -0x230(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x214(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x218(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq -0x210(%rbp), %rdi
callq 0x11a0
movq %rax, -0x238(%rbp)
jmp 0x2a86
movq -0x238(%rbp), %rdi
leaq 0x261a(%rip), %rsi      # 0x50ae
callq 0x10c0
jmp 0x2a9b
jmp 0x2a9d
movl -0x218(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x218(%rbp)
jmp 0x2a3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x1130
jmp 0x2b0e
leaq 0x2647(%rip), %rsi      # 0x511c
leaq -0x210(%rbp), %rdi
callq 0x10c0
jmp 0x2ae3
jmp 0x2ae5
movl -0x214(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x214(%rbp)
jmp 0x2a1d
leaq -0x210(%rbp), %rdi
callq 0x1130
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x1190
nopw (%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::MultiGridSolver(int*)
MultiGridSolver::MultiGridSolver(int *data)
{
	int grid_density = data[0];
	int no_of_grids = data[1];

	scheme = data[2];
	switch(scheme)
	{
		case 0:
			v1 		= data[3];
			v2 		= data[4];
			cycles 	= data[5];
			break;
		case 1:
			v1 		= data[3];
			v2 		= data[4];
			mu 		= data[5];
			cycles 	= data[6];
			break;
		case 2:
			v0 		= data[3];
			v1 		= data[4];
			v2 		= data[5];
			break;
	}

	Grid = new MultiGrid(grid_density, no_of_grids-1, 1.0, 0);

	// Boundary conditions applied to the finest grid alone
	Grid->apply_boundary_conditions();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3530
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x2be6
jmp 0x2bd2
movl -0x28(%rbp), %eax
subl $0x1, %eax
je 0x2c0a
jmp 0x2bdc
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x2c38
jmp 0x2c5a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2c5a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2c5a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movl $0x40, %edi
callq 0x10d0
movq %rax, -0x40(%rbp)
jmp 0x2c6a
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
decl %edx
movss 0x249a(%rip), %xmm0     # 0x5118
xorl %ecx, %ecx
callq 0x1590
jmp 0x2c87
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x2720
jmp 0x2c9c
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2cca
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x10e0
movq -0x38(%rbp), %rdi
callq 0x3550
movq -0x20(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::solve(double)
void MultiGridSolver::solve(real tol)
{
	GridData idata = {
		Grid->get_L2norm(),
		1,
		0
	};
	data.push_back(idata);

	switch(scheme)
	{
		case 0:
			while(Grid->get_L2norm() > tol)
			{
				V(Grid, v1, v2);
			}
			break;
		case 1:
			while(Grid->get_L2norm() > tol)
			{
				W(Grid, v1, v2, mu);
			}
			break;
		case 2:
			FMG(Grid, v0, v1, v2);
			while(Grid->get_L2norm() > tol)
			{
				V(Grid, v1, v2);
			}
			break;
		default:
			F(Grid, 1e-4, .3, 5);
			data.push_back(Grid->relax(20));
	}
	Grid->save_grid("out.dat");
	save_data("data.dat");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0x2b20
movq -0x50(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x35b0
movq -0x50(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0x2daa
jmp 0x2d93
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0x2dd8
jmp 0x2d9d
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x2e0a
jmp 0x2e49
jmp 0x2dac
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x2b20
ucomisd -0x10(%rbp), %xmm0
jbe 0x2dd3
movq -0x50(%rbp), %rdi
movq (%rdi), %rsi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
callq 0x2ec0
jmp 0x2dac
jmp 0x2e97
jmp 0x2dda
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x2b20
ucomisd -0x10(%rbp), %xmm0
jbe 0x2e05
movq -0x50(%rbp), %rdi
movq (%rdi), %rsi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
movl 0x18(%rdi), %r8d
callq 0x2fa0
jmp 0x2dda
jmp 0x2e97
movq -0x50(%rbp), %rdi
movq (%rdi), %rsi
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %r8d
callq 0x30b0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x2b20
ucomisd -0x10(%rbp), %xmm0
jbe 0x2e47
movq -0x50(%rbp), %rdi
movq (%rdi), %rsi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
callq 0x2ec0
jmp 0x2e20
jmp 0x2e97
movq -0x50(%rbp), %rdi
movq (%rdi), %rsi
movsd 0x22c8(%rip), %xmm0     # 0x5120
movsd 0x22c8(%rip), %xmm1     # 0x5128
movl $0x5, %edx
callq 0x3190
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
movl $0x14, %edx
callq 0x1fa0
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3620
movq -0x50(%rbp), %rax
movq (%rax), %rdi
leaq 0x2293(%rip), %rsi      # 0x5138
callq 0x29e0
movq -0x50(%rbp), %rdi
leaq 0x228b(%rip), %rsi      # 0x5140
callq 0x3320
addq $0x60, %rsp
popq %rbp
retq
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::V(MultiGrid*, int, int)
void MultiGridSolver::V(MultiGrid *grid, int v1, int v2)
{
	MultiGrid *cgrid = grid->grid2; // coarser grid

	data.push_back(grid->relax(v1));
	 // If coarser grid exists recursively apply V()
	if (cgrid)
	{
		// Restrict residue to coarse grid
		grid->calc_res_to_temp();
		grid->restrict();
		cgrid->copy_temp_to_f();

		// Set error 0 on coarse grid
		cgrid->set_v(0);

		// Continue V cycle
		V(cgrid, v1, v2);

		// Interpolate and add error to fine grid
		cgrid->copy_v_to_temp();
		grid->interp();
		grid->add_temp_to_v();
	}
	// Relax fine grid few more times
	data.push_back(grid->relax(v2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
callq 0x1fa0
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3620
cmpq $0x0, -0x20(%rbp)
je 0x2f6a
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x24f0
movq -0x20(%rbp), %rdi
callq 0x2880
movq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2800
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x2ec0
movq -0x20(%rbp), %rdi
callq 0x28e0
movq -0x10(%rbp), %rdi
callq 0x2250
movq -0x10(%rbp), %rdi
callq 0x2940
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0x1fa0
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3620
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::W(MultiGrid*, int, int, int)
void MultiGridSolver::W(MultiGrid *grid, int v1, int v2, int mu)
{
	MultiGrid *cgrid = grid->grid2; // coarser grid

	data.push_back(grid->relax(v1));
	 // If coarser grid exists recursively apply V()
	if (cgrid)
	{
		// Restrict residue to coarse grid
		grid->calc_res_to_temp();
		grid->restrict();
		cgrid->copy_temp_to_f();

		// Set error 0 on coarse grid
		cgrid->set_v(0);

		// Continue M cycle 'mu' times
		for (int i = 0; i < mu; ++i)
		{
			W(cgrid, v1, v2, mu);
		}

		// Interpolate and add error to fine grid
		cgrid->copy_v_to_temp();
		grid->interp();
		grid->add_temp_to_v();
	}
	// Relax fine grid few more times
	data.push_back(grid->relax(v2));	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
addq $0x20, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x1fa0
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3620
cmpq $0x0, -0x28(%rbp)
je 0x306f
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x24f0
movq -0x28(%rbp), %rdi
callq 0x2880
movq -0x28(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2800
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3054
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x2fa0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x302a
movq -0x28(%rbp), %rdi
callq 0x28e0
movq -0x10(%rbp), %rdi
callq 0x2250
movq -0x10(%rbp), %rdi
callq 0x2940
movq -0x70(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x1fa0
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3620
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::FMG(MultiGrid*, int, int, int)
void MultiGridSolver::FMG(MultiGrid *grid, int v0, int v1, int v2)
{
	MultiGrid *cgrid = grid->grid2; // coarser grid

	 // If coarser grid exists recursively apply FMG()
	if (cgrid)
	{
		// Restrict 'f' to coarse grid
		grid->copy_f_to_temp();
		grid->restrict();
		cgrid->copy_temp_to_f();

		// FMG cycle on coarser grid
		FMG(cgrid, v0, v1, v2);

		// Interpolate solution ('v') to fine grid
		cgrid->copy_v_to_temp();
		grid->interp();
		grid->set_v(0);
		grid->add_temp_to_v();
	}
	else // Base case
	{
		grid->set_v(0);
	}

	grid->apply_boundary_conditions();

	// Perform V cycle v0 times more times
	for (int i = 0; i < v0; ++i)
	{
		V(grid, v1, v2);	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x313f
movq -0x10(%rbp), %rdi
callq 0x2910
movq -0x10(%rbp), %rdi
callq 0x24f0
movq -0x28(%rbp), %rdi
callq 0x2880
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x30b0
movq -0x28(%rbp), %rdi
callq 0x28e0
movq -0x10(%rbp), %rdi
callq 0x2250
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2800
movq -0x10(%rbp), %rdi
callq 0x2940
jmp 0x314b
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2800
movq -0x10(%rbp), %rdi
callq 0x2720
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3181
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2ec0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x315b
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::F(MultiGrid*, double, double, int)
void MultiGridSolver::F(MultiGrid *grid, real alpha, real beta, int iter_max)
{
	MultiGrid *cgrid = grid->grid2; // coarser grid

	real R0 = grid->get_L2norm();
	real R2 = 10000, R1 = 1;
	for (int i = 0; i < iter_max && R2 > alpha*R0; ++i)
	{
		grid->relax_once();
		// V(grid, 0, 1);
		R1 = R2;
		R2 = grid->get_L2norm();

		// If poor convergence rates perform coarse grid corrections
		if(i > 1 && R2 > R1*beta)
		{
			// Restrict residue to coarse grid
			grid->calc_res_to_temp();
			grid->restrict();
			cgrid->copy_temp_to_f();

			// Set error 0 on coarse grid
			cgrid->set_v(0);

			// Apply flex cycles to coarse grid
			F(cgrid, alpha, beta, iter_max);

			// Interpolate and add error to fine grid
			cgrid->copy_v_to_temp();
			grid->interp();
			grid->add_temp_to_v();

			i--;
		}

		GridData idata = {
			R2,
			grid->get_wu(),
			1,
			grid->get_level()
		};

		data.push_back(idata);

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b20
movsd %xmm0, -0x38(%rbp)
movsd 0x1f57(%rip), %xmm0     # 0x5130
movsd %xmm0, -0x40(%rbp)
movsd 0x1f0a(%rip), %xmm0     # 0x50f0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x24(%rbp), %ecx
movb %al, -0x71(%rbp)
jge 0x3218
movsd -0x40(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x3224
jmp 0x330f
movq -0x10(%rbp), %rdi
callq 0x1a50
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b20
movsd %xmm0, -0x40(%rbp)
cmpl $0x1, -0x4c(%rbp)
jle 0x32c5
movsd -0x40(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x32c5
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x24f0
movq -0x30(%rbp), %rdi
callq 0x2880
movq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2800
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x24(%rbp), %edx
callq 0x3190
movq -0x30(%rbp), %rdi
callq 0x28e0
movq -0x10(%rbp), %rdi
callq 0x2250
movq -0x10(%rbp), %rdi
callq 0x2940
movl -0x4c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b50
movsd %xmm0, -0x60(%rbp)
movl $0x1, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2210
movq -0x70(%rbp), %rdi
movl %eax, -0x54(%rbp)
addq $0x20, %rdi
leaq -0x68(%rbp), %rsi
callq 0x35b0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x31f2
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)