LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::rotateEdges(Cube::Edges, bool)
void Cube::rotateEdges(Edges start, bool clockwise) {
    unsigned int index0 = start*cubeSize;
    unsigned int index1 = index0 + cubeSize;
    unsigned int index2 = index1 + cubeSize;
    unsigned int index3 = index2 + cubeSize;
   
    for (unsigned int i=0; i<cubeSize; i++)
        fourWayRotate({{edges[index0 + i].row, edges[index0 + i].col},
                       {edges[index1 + i].row, edges[index1 + i].col},
                       {edges[index2 + i].row, edges[index2 + i].col},
                       {edges[index3 + i].row, edges[index3 + i].col}},
                       clockwise);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl -0xc(%rbp), %eax
imull 0x8(%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl 0x8(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl 0x8(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl 0x8(%rcx), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x8ae3
movq -0x50(%rbp), %rdi
movq 0x18(%rdi), %rax
movl -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x48(%rbp)
movq 0x18(%rdi), %rax
movl -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x44(%rbp)
movq 0x18(%rdi), %rax
movl -0x18(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x40(%rbp)
movq 0x18(%rdi), %rax
movl -0x18(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x3c(%rbp)
movq 0x18(%rdi), %rax
movl -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x38(%rbp)
movq 0x18(%rdi), %rax
movl -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x34(%rbp)
movq 0x18(%rdi), %rax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdi), %rax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x2c(%rbp)
movb -0xd(%rbp), %al
leaq -0x48(%rbp), %rcx
andb $0x1, %al
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movzbl %al, %esi
callq 0x8b80
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x89fa
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::getLayerUpperLeft(Coordinate&, Layer)
void Cube::getLayerUpperLeft(Coordinate& coord, Layer l) {
    /* Layers that are not (yet?) supported. */
    if (l == Layer::M || l == Layer::E || l == Layer::S)
        return;

    if (l == Layer::NOLAYER)
        return;

    coord.col = (l%LAYERS_PER_ROW)*cubeSize;
    if (l < LAYERS_PER_ROW)
        coord.row = 0;
    else if (l < LAYERS_PER_ROW*2)
        coord.row = cubeSize;
    else
        coord.row = cubeSize*2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0xa, -0x14(%rbp)
je 0x8b19
cmpl $0xb, -0x14(%rbp)
je 0x8b19
cmpl $0xc, -0x14(%rbp)
jne 0x8b1b
jmp 0x8b7e
cmpl $0xd, -0x14(%rbp)
jne 0x8b23
jmp 0x8b7e
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl 0x2c(%rcx)
imull 0x8(%rcx), %edx
movq -0x10(%rbp), %rax
movl %edx, 0x4(%rax)
movl -0x14(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jae 0x8b4e
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x8b7e
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x2c(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jae 0x8b6d
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x8b7c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
shll %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x8b7e
popq %rbp
retq
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::fourWayRotate(Cube::Square, bool)
void Cube::fourWayRotate(Square square, bool clockwise) {
    CubieColor tmp = cube[square.ll.row][square.ll.col];
    if (clockwise) {
        cube[square.ll.row][square.ll.col] = cube[square.lr.row][square.lr.col];
        cube[square.lr.row][square.lr.col] = cube[square.ur.row][square.ur.col];
        cube[square.ur.row][square.ur.col] = cube[square.ul.row][square.ul.col];
        cube[square.ul.row][square.ul.col] = tmp;
    } else {
        cube[square.ll.row][square.ll.col] = cube[square.ul.row][square.ul.col];
        cube[square.ul.row][square.ul.col] = cube[square.ur.row][square.ur.col];
        cube[square.ur.row][square.ur.col] = cube[square.lr.row][square.lr.col];
        cube[square.lr.row][square.lr.col] = tmp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rax
movl 0x18(%rcx), %edx
movq (%rax,%rdx,8), %rax
movl 0x1c(%rcx), %ecx
movb (%rax,%rcx), %al
movb %al, -0xa(%rbp)
testb $0x1, -0x9(%rbp)
je 0x8c49
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movl 0x10(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x14(%rcx), %esi
movb (%rdx,%rsi), %dil
movq 0x10(%rax), %rdx
movl 0x18(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x1c(%rcx), %esi
movb %dil, (%rdx,%rsi)
movq 0x10(%rax), %rdx
movl 0x8(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0xc(%rcx), %esi
movb (%rdx,%rsi), %dil
movq 0x10(%rax), %rdx
movl 0x10(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x14(%rcx), %esi
movb %dil, (%rdx,%rsi)
movq 0x10(%rax), %rdx
movl (%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x4(%rcx), %esi
movb (%rdx,%rsi), %dil
movq 0x10(%rax), %rdx
movl 0x8(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0xc(%rcx), %esi
movb %dil, (%rdx,%rsi)
movb -0xa(%rbp), %dl
movq 0x10(%rax), %rax
movl (%rcx), %esi
movq (%rax,%rsi,8), %rax
movl 0x4(%rcx), %ecx
movb %dl, (%rax,%rcx)
jmp 0x8ccf
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movl (%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x4(%rcx), %esi
movb (%rdx,%rsi), %dil
movq 0x10(%rax), %rdx
movl 0x18(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x1c(%rcx), %esi
movb %dil, (%rdx,%rsi)
movq 0x10(%rax), %rdx
movl 0x8(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0xc(%rcx), %esi
movb (%rdx,%rsi), %dil
movq 0x10(%rax), %rdx
movl (%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x4(%rcx), %esi
movb %dil, (%rdx,%rsi)
movq 0x10(%rax), %rdx
movl 0x10(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0x14(%rcx), %esi
movb (%rdx,%rsi), %dil
movq 0x10(%rax), %rdx
movl 0x8(%rcx), %esi
movq (%rdx,%rsi,8), %rdx
movl 0xc(%rcx), %esi
movb %dil, (%rdx,%rsi)
movb -0xa(%rbp), %dl
movq 0x10(%rax), %rax
movl 0x10(%rcx), %esi
movq (%rax,%rsi,8), %rax
movl 0x14(%rcx), %ecx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeEdges()
void Cube::initializeEdges() {
    edges = new Coordinate[NUM_EDGE_TYPES*cubeSize];

    initializeFaceEdges();
    initializeUpEdges();
    initializeLeftEdges();
    initializeRightEdges();
    initializeDownEdges();
    initializeBackEdges();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x30(%rcx), %eax
imull 0x8(%rcx), %eax
movl %eax, %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
movq %rax, 0x18(%rdi)
callq 0x8f70
movq -0x10(%rbp), %rdi
callq 0x9080
movq -0x10(%rbp), %rdi
callq 0x9190
movq -0x10(%rbp), %rdi
callq 0x9290
movq -0x10(%rbp), %rdi
callq 0x93a0
movq -0x10(%rbp), %rdi
callq 0x94a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeLayer(Layer, CubieColor)
void Cube::initializeLayer(Layer layer, CubieColor color) {
    /**
     * We have to set this to a throw-away value because -Ofast optimization
     * causes an unassigned variable to emit -Werror=maybe-uninitialized. This
     * warning cannot be squelched when using LLVM because of LLVM bug
     * https://bugs.llvm.org/show_bug.cgi?id=24979
     */
    Coordinate ul = {Layer::U, true};
    getLayerUpperLeft(ul, layer);

    for (unsigned int r = ul.row; r < (ul.row + cubeSize); r++)
        for (unsigned int c = ul.col; c < (ul.col + cubeSize); c++)
            cube[r][c] = color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x73a5(%rip), %rax      # 0x10298
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edx
leaq -0x18(%rbp), %rsi
callq 0x8af0
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x8f61
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rdx
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x8f54
movq -0x28(%rbp), %rax
movb -0xd(%rbp), %dl
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8f20
jmp 0x8f56
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8f09
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeFaceEdges()
void Cube::initializeFaceEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::F);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = ul.row - 1;
        c1.col = ul.col + i;
        edges[i + Edges::UpFace*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row + i;
        c2.col = ul.col + cubeSize;
        edges[i + Edges::RightFace*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row + cubeSize;
        c3.col = ul.col + cubeSize - 1 - i;
        edges[i + Edges::DownFace*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = ul.col - 1;
        edges[i + Edges::LeftFace*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x5, %edx
callq 0x8af0
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x906e
movq -0x40(%rbp), %rdx
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x0, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x1c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl 0x8(%rdx), %eax
movl %eax, -0x20(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rdx), %esi
shll $0x0, %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x24(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl 0x8(%rdx), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
addl 0x8(%rdx), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rdx), %esi
shll %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x2c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl 0x8(%rdx), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x3, 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, %ecx
movq -0x34(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8f99
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeUpEdges()
void Cube::initializeUpEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::U);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = cubeSize;
        c1.col = ul.col + cubeSize - 1 - i;
        edges[i + Edges::FaceUp*cubeSize] = c1;

        Coordinate c2;
        c2.row = cubeSize;
        c2.col = ul.col - 1 - i;
        edges[i + Edges::LeftUp*cubeSize] = c2;

        Coordinate c3;
        c3.row = cubeSize;
        c3.col = ul.col + cubeSize*3 - 1 - i;
        edges[i + Edges::BackUp*cubeSize] = c3;

        Coordinate c4;
        c4.row = cubeSize;
        c4.col = ul.col + cubeSize*2 - 1 - i;
        edges[i + Edges::RightUp*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x8af0
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x9181
movq -0x40(%rbp), %rdx
movl 0x8(%rdx), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl 0x8(%rdx), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rdx), %esi
shll $0x2, %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x1c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl 0x8(%rdx), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x5, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x24(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl 0x8(%rdx), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
imull $0x3, 0x8(%rdx), %ecx
addl %ecx, %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x6, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x2c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl 0x8(%rdx), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
movl 0x8(%rdx), %ecx
shll %ecx
addl %ecx, %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x7, 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, %ecx
movq -0x34(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x90a9
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeLeftEdges()
void Cube::initializeLeftEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::L);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = i;
        c1.col = cubeSize;
        edges[i + Edges::UpLeft*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row + i;
        c2.col = cubeSize;
        edges[i + Edges::FaceLeft*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row + cubeSize + i;
        c3.col = cubeSize;
        edges[i + Edges::DownLeft*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = cubeSize*4 - 1;
        edges[i + Edges::BackLeft*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x8af0
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x9281
movq -0x40(%rbp), %rdx
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl 0x8(%rdx), %eax
movl %eax, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rdx), %esi
shll $0x3, %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x1c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl 0x8(%rdx), %eax
movl %eax, -0x20(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x9, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x24(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl 0x8(%rdx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl 0x8(%rdx), %eax
movl %eax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0xa, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x2c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl 0x8(%rdx), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl 0x8(%rdx), %eax
shll $0x2, %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0xb, 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, %ecx
movq -0x34(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x91b9
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeRightEdges()
void Cube::initializeRightEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::R);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = ul.row - 1 - i;
        c1.col = ul.col - 1;
        edges[i + Edges::UpRight*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row + i;
        c2.col = ul.col + cubeSize;
        edges[i + Edges::BackRight*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row + cubeSize*2 - 1 - i;
        c3.col = ul.col - 1;
        edges[i + Edges::DownRight*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = ul.col - 1;
        edges[i + Edges::FaceRight*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x6, %edx
callq 0x8af0
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x9392
movq -0x40(%rbp), %rdx
movl -0x10(%rbp), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0xc, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x1c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl 0x8(%rdx), %eax
movl %eax, -0x20(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0xd, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x24(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
movl 0x8(%rdx), %ecx
shll %ecx
addl %ecx, %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0xe, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x2c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl 0x8(%rdx), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0xf, 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, %ecx
movq -0x34(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x92b9
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeDownEdges()
void Cube::initializeDownEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::D);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = ul.row - 1;
        c1.col = ul.col + i;
        edges[i + Edges::FaceDown*cubeSize] = c1;

        Coordinate c2;
        c2.row = ul.row - 1;
        c2.col = ul.col + cubeSize + i;
        edges[i + Edges::RightDown*cubeSize] = c2;

        Coordinate c3;
        c3.row = ul.row - 1;
        c3.col = ul.col + cubeSize*2 + i;
        edges[i + Edges::BackDown*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row - 1;
        c4.col = i;
        edges[i + Edges::LeftDown*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x9, %edx
callq 0x8af0
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x9498
movq -0x40(%rbp), %rdx
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rdx), %esi
shll $0x4, %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x1c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl 0x8(%rdx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x11, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x24(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movl 0x8(%rdx), %ecx
shll %ecx
addl %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x12, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x2c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x13, 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, %ecx
movq -0x34(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x93c9
addq $0x40, %rsp
popq %rbp
retq
nop
// File: chuckwolber[P]Cube/test/../Cube.cpp
// Function: Cube::initializeBackEdges()
void Cube::initializeBackEdges() {
    Coordinate ul;
    getLayerUpperLeft(ul, Layer::B);

    for (unsigned int i=0; i<cubeSize; i++) {
        Coordinate c1;
        c1.row = 0;
        c1.col = cubeSize*2 - 1 - i;
        edges[i + Edges::UpBack*cubeSize] = c1;

        Coordinate c2;
        c2.row = cubeSize + i;
        c2.col = 0;
        edges[i + Edges::LeftBack*cubeSize] = c2;

        Coordinate c3;
        c3.row = cubeSize*3 - 1;
        c3.col = cubeSize + i;
        edges[i + Edges::DownBack*cubeSize] = c3;

        Coordinate c4;
        c4.row = ul.row + cubeSize - 1 - i;
        c4.col = ul.col - 1;
        edges[i + Edges::RightBack*cubeSize] = c4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x7, %edx
callq 0x8af0
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x9597
movq -0x40(%rbp), %rdx
movl $0x0, -0x1c(%rbp)
movl 0x8(%rdx), %eax
shll %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x14, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x1c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl 0x8(%rdx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x15, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x24(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
imull $0x3, 0x8(%rdx), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl 0x8(%rdx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x16, 0x8(%rdx), %esi
addl %esi, %ecx
movl %ecx, %ecx
movq -0x2c(%rbp), %rsi
movq %rsi, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl 0x8(%rdx), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rdx), %rax
movl -0x14(%rbp), %ecx
imull $0x17, 0x8(%rdx), %edx
addl %edx, %ecx
movl %ecx, %ecx
movq -0x34(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x94c9
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: main
int main() {
    test_constructors();
    test_inequalities();
    test_sequences();
    test_skip();
    test_addTurn();
    test_setAlgorithm();
    test_inversions();
    test_hidden_inversions();
    test_triples();
    test_hidden_triples();
    test_string();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x9ff0
callq 0xa650
callq 0xa6e0
callq 0xad90
callq 0xb080
callq 0xb5c0
callq 0xb890
callq 0xc2e0
callq 0xc9d0
callq 0xcff0
callq 0xeb00
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: test_inequalities()
void test_inequalities() {
    std::cout << "Testing inequalities... ";

    unsigned int val = 1;
    test_inequalities(val + 2);
    test_inequalities(val *= 12 + 3);
    test_inequalities(val *= 12 + 4);
    test_inequalities(val *= 12 + 5);
    test_inequalities(val *= 12 + 6); 

    std::cout << "Passed" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xb979(%rip), %rdi      # 0x15fd8
leaq 0x5d57(%rip), %rsi      # 0x103bd
callq 0x2190
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x2, %edi
callq 0xedf0
imull $0xf, -0x4(%rbp), %edi
movl %edi, -0x4(%rbp)
callq 0xedf0
movl -0x4(%rbp), %edi
shll $0x4, %edi
movl %edi, -0x4(%rbp)
callq 0xedf0
imull $0x11, -0x4(%rbp), %edi
movl %edi, -0x4(%rbp)
callq 0xedf0
imull $0x12, -0x4(%rbp), %edi
movl %edi, -0x4(%rbp)
callq 0xedf0
movq 0xb922(%rip), %rdi      # 0x15fd8
leaq 0x5cf9(%rip), %rsi      # 0x103b6
callq 0x2190
movq %rax, %rdi
movq 0xb8fc(%rip), %rsi      # 0x15fc8
callq 0x21c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: test_string()
void test_string() {
    std::cout << "Testing string... ";

    std::string str_1 = "F' L U' R' D B F'";
    std::string str_2;
    Algorithm alg_1;

    alg_1.setAlgorithm(str_1.c_str());
    str_2 = alg_1.getAlgorithmStr();

    assert(str_1.compare(str_2) == 0);

    std::cout << "Passed" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x74c6(%rip), %rdi      # 0x15fd8
leaq 0x1e74(%rip), %rsi      # 0x1098d
callq 0x2190
leaq -0x21(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x22b0
movq -0xa8(%rbp), %rdx
leaq 0x1e64(%rip), %rsi      # 0x109a0
leaq -0x20(%rbp), %rdi
callq 0x4fd0
jmp 0xeb47
leaq -0x21(%rbp), %rdi
callq 0x21e0
leaq -0x58(%rbp), %rdi
callq 0x2240
leaq -0x80(%rbp), %rdi
callq 0x2420
jmp 0xeb64
leaq -0x20(%rbp), %rdi
callq 0x20a0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x2850
jmp 0xeb7b
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3100
jmp 0xeb8d
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0xa0(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x2210
movq -0xc0(%rbp), %rdi
callq 0x20e0
movq -0xb8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2040
movl %eax, -0xac(%rbp)
jmp 0xebcf
movl -0xac(%rbp), %eax
cmpl $0x0, %eax
jne 0xebdc
jmp 0xec3a
leaq 0x1dcf(%rip), %rdi      # 0x109b2
leaq 0x16ef(%rip), %rsi      # 0x102d9
movl $0x252, %edx            # imm = 0x252
leaq 0x1dd6(%rip), %rcx      # 0x109cc
callq 0x2100
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x21e0
jmp 0xeca1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xec8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4bd0
jmp 0xec8f
movq 0x7397(%rip), %rdi      # 0x15fd8
leaq 0x176e(%rip), %rsi      # 0x103b6
callq 0x2190
movq %rax, -0xc8(%rbp)
jmp 0xec56
movq -0xc8(%rbp), %rdi
movq 0x7364(%rip), %rsi      # 0x15fc8
callq 0x21c0
jmp 0xec6b
leaq -0x80(%rbp), %rdi
callq 0x4bd0
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x20(%rbp), %rdi
callq 0x20e0
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x20(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: chuckwolber[P]Cube/test/test_algorithm.cpp
// Function: verify_turns(std::vector<Turn, std::allocator<Turn>>, std::vector<Turn, std::allocator<Turn>>)
void verify_turns(std::vector<Turn> results, std::vector<Turn> expected) {
    assert(results.size() == expected.size());
    for (unsigned int i = 0; i < expected.size(); i++) {
        assert(expected.at(i).layer     == results.at(i).layer);
        assert(expected.at(i).clockwise == results.at(i).clockwise);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5410
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x5410
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0xece8
jmp 0xed07
leaq 0x1be4(%rip), %rdi      # 0x108d3
leaq 0x15e3(%rip), %rsi      # 0x102d9
movl $0x241, %edx            # imm = 0x241
leaq 0x1bf3(%rip), %rcx      # 0x108f5
callq 0x2100
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x5410
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xede5
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xf2a0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xf2a0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl (%rcx), %eax
jne 0xed5b
jmp 0xed7a
leaq 0x1bcb(%rip), %rdi      # 0x1092d
leaq 0x1570(%rip), %rsi      # 0x102d9
movl $0x243, %edx            # imm = 0x243
leaq 0x1b80(%rip), %rcx      # 0x108f5
callq 0x2100
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xf2a0
movq -0x30(%rbp), %rdi
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xf2a0
movq %rax, %rcx
movl -0x40(%rbp), %eax
movb 0x4(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xedb6
jmp 0xedd5
leaq 0x1b9c(%rip), %rdi      # 0x10959
leaq 0x1515(%rip), %rsi      # 0x102d9
movl $0x244, %edx            # imm = 0x244
leaq 0x1b25(%rip), %rcx      # 0x108f5
callq 0x2100
jmp 0xedd7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xed0e
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_vector_resize_inline_example.cpp
// Function: my_vv_size_handler_t<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t parameters) override
   {
      vector_t vector(parameters[0]);
      size_t   new_size = static_cast<std::size_t>(scalar_t(parameters[1])());
      void*    key      = static_cast<void*>(&vector[0]);

      typename map_t::iterator itr = vector_map_.find(key);

      if (itr == vector_map_.end())
      {
         printf("my_vv_size_handler - Error: failed to find vector_view for address: %p\n",key);
         return T(0);
      }

      exprtk::vector_view<T>& vv = *itr->second;

      if (vv.base_size() < new_size)
      {
         printf("my_vv_size_handler - Error: vector_view for address: %p new size of %d greater than base_size of %d\n",
                key,
                static_cast<unsigned int>(new_size),
                static_cast<unsigned int>(vv.base_size()));
         return T(0);
      }

      return vv.set_size(new_size) ? T(1) : T(0);
   }

// Assembly:
subq $0xa8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x78(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x78(%rsp), %rsi
callq 0x11c890
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x11ca00
movq 0x20(%rsp), %rdi
movq $0x1, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x11c890
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x11c910
movq 0x28(%rsp), %rdi
callq 0x11d080
movsd (%rax), %xmm0
movsd 0x32b1cc(%rip), %xmm2   # 0x448010
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x70(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x11d090
movq 0x30(%rsp), %rdi
movq %rax, 0x58(%rsp)
addq $0x48, %rdi
leaq 0x58(%rsp), %rsi
callq 0x11d0c0
movq 0x30(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x48, %rdi
callq 0x11d110
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11d0f0
testb $0x1, %al
jne 0x11cec7
jmp 0x11ceeb
movq 0x58(%rsp), %rsi
leaq 0x330a3b(%rip), %rdi    # 0x44d90e
movb $0x0, %al
callq 0x111080
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0x11cf96
leaq 0x48(%rsp), %rdi
callq 0x11d140
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11d170
cmpq 0x70(%rsp), %rax
jae 0x11cf53
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11d170
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl %eax, %ecx
leaq 0x330a18(%rip), %rdi    # 0x44d956
movb $0x0, %al
callq 0x111080
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0x11cf96
movq 0x38(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x11d180
movsd 0x32b0ae(%rip), %xmm0   # 0x448018
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x11cf87
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: ScanForToken(char, int&, int&, bool, bool, int*)
bool ScanForToken(char cToken, int &iIndex, int &iLine, bool bIgnoreWhiteSpace, bool bIgnoreOthers, int *iToken = 0)
{
	for(; iIndex < g_entdatasize; iIndex++)
	{
		// If we found a null char, consider it end of data.
		if(g_dentdata[iIndex] == '\0')
		{
			iIndex = g_entdatasize;
			return false;
		}

		// Count lines (for error message).
		if(g_dentdata[iIndex] == '\n')
		{
			iLine++;
		}

		// Ignore white space, if we are ignoring it.
		if(!bIgnoreWhiteSpace && isspace(g_dentdata[iIndex]))
		{
			continue;
		}

		if(g_dentdata[iIndex] != cToken)
		{
			if(bIgnoreOthers)
				continue;
			else
				return false;
		}

		// Advance the index past the token.
		iIndex++;

		// Return the index of the token if requested.
		if(iToken != 0)
		{
			*iToken = iIndex - 1;
		}

		return true;
	}

	// End of data.
	return false;
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movb %dil, 0x26(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
andb $0x1, %cl
movb %cl, 0xf(%rsp)
andb $0x1, %al
movb %al, 0xe(%rsp)
movq %r9, (%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
leaq 0x81578f(%rip), %rcx    # 0x826334
cmpl (%rcx), %eax
jge 0x10c90
movq 0x18(%rsp), %rax
movslq (%rax), %rcx
leaq 0x815784(%rip), %rax    # 0x826340
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x10bdf
leaq 0x815768(%rip), %rax    # 0x826334
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x10c95
movq 0x18(%rsp), %rax
movslq (%rax), %rcx
leaq 0x815752(%rip), %rax    # 0x826340
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x10c03
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
testb $0x1, 0xf(%rsp)
jne 0x10c29
movq 0x18(%rsp), %rax
movslq (%rax), %rcx
leaq 0x815727(%rip), %rax    # 0x826340
movsbl (%rax,%rcx), %edi
callq 0x3080
cmpl $0x0, %eax
je 0x10c29
jmp 0x10c7f
movq 0x18(%rsp), %rax
movslq (%rax), %rcx
leaq 0x815708(%rip), %rax    # 0x826340
movsbl (%rax,%rcx), %eax
movsbl 0x26(%rsp), %ecx
cmpl %ecx, %eax
je 0x10c55
testb $0x1, 0xe(%rsp)
je 0x10c4e
jmp 0x10c7f
movb $0x0, 0x27(%rsp)
jmp 0x10c95
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpq $0x0, (%rsp)
je 0x10c78
movq 0x18(%rsp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x27(%rsp)
jmp 0x10c95
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x10b97
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: Usage()
static void     Usage(void)
{
    //Log("%s " ZHLT_VERSIONSTRING "\n" MODIFICATIONS_STRING "\n", g_Program);
    //Log("  Usage: ripent [-import|-export] [-texdata n] bspname\n");

	// Modified to behave like other tools by Nem.

	Banner();
	Log("\n-= %s Options =-\n\n", g_Program);

#ifdef ZHLT_CONSOLE
	Log("    -console #      : Set to 0 to turn off the pop-up console (default is 1)\n");
#endif
#ifdef ZHLT_LANGFILE
	Log("    -lang file      : localization file\n");
#endif
	Log("    -export         : Export entity data\n");
	Log("    -import         : Import entity data\n\n");

	Log("    -parse          : Parse and format entity data\n\n");
#ifdef RIPENT_TEXTURE
	Log("    -textureexport  : Export texture data\n");
	Log("    -textureimport  : Import texture data\n");
	Log("    -textureparse   : Parse and format texture data\n\n");
#endif
#ifdef ZHLT_64BIT_FIX
	Log("    -writeextentfile : Create extent file for the map\n");
#endif
#ifdef ZHLT_EMBEDLIGHTMAP
#ifdef RIPENT_TEXTURE
	Log("    -deleteembeddedlightmaps : Delete textures created by hlrad\n");
#endif
#endif

    Log("    -texdata #      : Alter maximum texture memory limit (in kb)\n");
    Log("    -lightdata #    : Alter maximum lighting memory limit (in kb)\n");
	Log("    -chart          : Display bsp statitics\n");
	Log("    -noinfo         : Do not show tool configuration information\n\n");
#ifdef RIPENT_PAUSE
	Log("    -pause          : Pause before exit\n\n");
#endif

	Log("    mapfile         : The mapfile to process\n\n");

    exit(1);
}

// Assembly:
pushq %rax
callq 0xab50
leaq 0xafe3(%rip), %rax      # 0x1d2b0
movq (%rax), %rsi
leaq 0x65b0(%rip), %rdi      # 0x18887
movb $0x0, %al
callq 0x9f40
leaq 0x65b6(%rip), %rdi      # 0x1889b
movb $0x0, %al
callq 0x9f40
leaq 0x65f6(%rip), %rdi      # 0x188e9
movb $0x0, %al
callq 0x9f40
leaq 0x6611(%rip), %rdi      # 0x18912
movb $0x0, %al
callq 0x9f40
leaq 0x662d(%rip), %rdi      # 0x1893c
movb $0x0, %al
callq 0x9f40
leaq 0x664a(%rip), %rdi      # 0x18967
movb $0x0, %al
callq 0x9f40
leaq 0x6671(%rip), %rdi      # 0x1899c
movb $0x0, %al
callq 0x9f40
leaq 0x668e(%rip), %rdi      # 0x189c7
movb $0x0, %al
callq 0x9f40
leaq 0x66ab(%rip), %rdi      # 0x189f2
movb $0x0, %al
callq 0x9f40
leaq 0x66d3(%rip), %rdi      # 0x18a28
movb $0x0, %al
callq 0x9f40
leaq 0x66fc(%rip), %rdi      # 0x18a5f
movb $0x0, %al
callq 0x9f40
leaq 0x672f(%rip), %rdi      # 0x18aa0
movb $0x0, %al
callq 0x9f40
leaq 0x6763(%rip), %rdi      # 0x18ae2
movb $0x0, %al
callq 0x9f40
leaq 0x6798(%rip), %rdi      # 0x18b25
movb $0x0, %al
callq 0x9f40
leaq 0x67b7(%rip), %rdi      # 0x18b52
movb $0x0, %al
callq 0x9f40
leaq 0x67ec(%rip), %rdi      # 0x18b95
movb $0x0, %al
callq 0x9f40
movl $0x1, %edi
callq 0x3320
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: ReadBSP(char const*)
static void     ReadBSP(const char* const name)
{
    char            filename[_MAX_PATH];

#ifdef ZHLT_DEFAULTEXTENSION_FIX
	safe_snprintf(filename, _MAX_PATH, "%s.bsp", name);

	LoadBSPFile(filename);
#else
    safe_strncpy(filename, name, _MAX_PATH);
    StripExtension(filename);
    DefaultExtension(filename, ".bsp");

    LoadBSPFile(name);
#endif
#ifdef ZHLT_64BIT_FIX
	if (g_writeextentfile)
	{
#ifdef PLATFORM_CAN_CALC_EXTENT
		hlassume (CalcFaceExtents_test (), assume_first);
		char extentfilename[_MAX_PATH];
		safe_snprintf (extentfilename, _MAX_PATH, "%s.ext", name);
		Log ("\nWriting %s.\n", extentfilename);
		WriteExtentFile (extentfilename);
#else
		Error ("-writeextentfile is not allowed in the " PLATFORM_VERSIONSTRING " version. Please use the 32-bit version of ripent.");
#endif
	}
#endif
}

// Assembly:
subq $0x2008, %rsp           # imm = 0x2008
movq %rdi, 0x2000(%rsp)
leaq 0x1000(%rsp), %rdi
movq 0x2000(%rsp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0x444c(%rip), %rdx      # 0x16aa7
movb $0x0, %al
callq 0x8350
leaq 0x1000(%rsp), %rdi
callq 0x39a0
testb $0x1, 0x208f12e(%rip)   # 0x20a17a4
je 0x126c1
callq 0x4e60
movzbl %al, %edi
andl $0x1, %edi
xorl %esi, %esi
callq 0xad70
movq %rsp, %rdi
movq 0x2000(%rsp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0x446e(%rip), %rdx      # 0x16b0f
movb $0x0, %al
callq 0x8350
movq %rsp, %rsi
leaq 0x66f9(%rip), %rdi      # 0x18dab
movb $0x0, %al
callq 0x9f40
movq %rsp, %rdi
callq 0x5250
addq $0x2008, %rsp           # imm = 0x2008
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/ripent/ripent.cpp
// Function: WriteEntities(char const*)
static void     WriteEntities(const char* const name)
{
#ifdef RIPENT_TEXTURE
	char *bak_dentdata;
	int bak_entdatasize;
#endif
    char filename[_MAX_PATH];

#ifdef ZHLT_DEFAULTEXTENSION_FIX
	safe_snprintf(filename, _MAX_PATH, "%s.ent", name);
#else
    safe_strncpy(filename, name, _MAX_PATH);
    StripExtension(filename);
    DefaultExtension(filename, ".ent");
#endif
    _unlink(filename);

    {
		if(g_parse)  // Added by Nem.
		{
#ifdef RIPENT_TEXTURE
			bak_entdatasize = g_entdatasize;
			bak_dentdata = (char *)malloc (g_entdatasize);
			hlassume (bak_dentdata != NULL, assume_NoMemory);
			memcpy (bak_dentdata, g_dentdata, g_entdatasize);
#endif
			ParseEntityData("  ", 2, "\r\n", 2, "", 0);
		}

        FILE *f = SafeOpenWrite(filename);
		Log("\nWriting %s.\n", filename);  // Added by Nem.
        SafeWrite(f, g_dentdata, g_entdatasize);
        fclose(f);
#ifdef RIPENT_TEXTURE
		if (g_parse)
		{
			g_entdatasize = bak_entdatasize;
			memcpy (g_dentdata, bak_dentdata, bak_entdatasize);
			free (bak_dentdata);
		}
#endif
    }
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x1020(%rsp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0x6521(%rip), %rdx      # 0x18db9
movb $0x0, %al
callq 0x8350
leaq 0x10(%rsp), %rdi
callq 0x3140
testb $0x1, 0x208eef1(%rip)   # 0x20a17a1
je 0x1293b
leaq 0x813a77(%rip), %rax    # 0x826334
movl (%rax), %eax
movl %eax, 0x1014(%rsp)
leaq 0x813a67(%rip), %rax    # 0x826334
movslq (%rax), %rdi
callq 0x3370
movq %rax, 0x1018(%rsp)
cmpq $0x0, 0x1018(%rsp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xad70
movq 0x1018(%rsp), %rdi
leaq 0x813a2c(%rip), %rax    # 0x826334
movslq (%rax), %rdx
leaq 0x813a2e(%rip), %rsi    # 0x826340
callq 0x3210
leaq 0x2d4d(%rip), %rdi      # 0x1566b
movl $0x2, %ecx
leaq 0x652d(%rip), %rdx      # 0x18e57
leaq 0x43f8(%rip), %r8       # 0x16d29
xorl %r9d, %r9d
movl %ecx, %esi
callq 0x10ca0
leaq 0x10(%rsp), %rdi
callq 0x9990
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
leaq 0x6455(%rip), %rdi      # 0x18dab
movb $0x0, %al
callq 0x9f40
movq 0x8(%rsp), %rdi
leaq 0x8139cb(%rip), %rax    # 0x826334
movl (%rax), %edx
leaq 0x8139ce(%rip), %rsi    # 0x826340
callq 0x9aa0
movq 0x8(%rsp), %rdi
callq 0x3290
testb $0x1, 0x208ee19(%rip)   # 0x20a17a1
je 0x129c3
movl 0x1014(%rsp), %ecx
leaq 0x81399c(%rip), %rax    # 0x826334
movl %ecx, (%rax)
movq 0x1018(%rsp), %rsi
movslq 0x1014(%rsp), %rdx
leaq 0x81398f(%rip), %rdi    # 0x826340
callq 0x3210
movq 0x1018(%rsp), %rdi
callq 0x3310
addq $0x1028, %rsp           # imm = 0x1028
retq
nopl (%rax,%rax)
// File: brianwu02[P]ImageProcessing/error_diffusion1.cpp
// Function: main
int main(int argc, char** argv) {
    int mtd, serpentine;
    float gamma;
    imageP I1, I2;

    cout << "input: " << argv[1] << endl;
    cout << "mtd: " << argv[2] << endl;
    cout << "serpentine: " << argv[3] << endl;
    cout << "gamma: " << argv[4] << endl;
    cout << "outfile " << argv[5] << endl;

    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;

    mtd = atoi(argv[2]);
    serpentine = atoi(argv[3]);
    gamma = atof(argv[4]);


    error_diffusion(I1, mtd, serpentine, gamma, I2);

    IP_saveImage(I2, argv[5]);

    IP_freeImage(I1);
    IP_freeImage(I2);

    cout << "done!" << endl;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3c43(%rip), %rdi      # 0x4fd0
leaq 0x1c8c(%rip), %rsi      # 0x3020
callq 0x10a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10a0
movq %rax, %rdi
movq 0x3c0d(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq 0x3c11(%rip), %rdi      # 0x4fd0
leaq 0x1c62(%rip), %rsi      # 0x3028
callq 0x10a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10a0
movq %rax, %rdi
movq 0x3bdb(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq 0x3bdf(%rip), %rdi      # 0x4fd0
leaq 0x1c36(%rip), %rsi      # 0x302e
callq 0x10a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x10a0
movq %rax, %rdi
movq 0x3ba9(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq 0x3bad(%rip), %rdi      # 0x4fd0
leaq 0x1c11(%rip), %rsi      # 0x303b
callq 0x10a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x10a0
movq %rax, %rdi
movq 0x3b77(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq 0x3b7b(%rip), %rdi      # 0x4fd0
leaq 0x1be7(%rip), %rsi      # 0x3043
callq 0x10a0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x10a0
movq %rax, %rdi
movq 0x3b45(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1b90
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x1120
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1160
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1160
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10f0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movss -0x1c(%rbp), %xmm0
movq -0x30(%rbp), %rcx
callq 0x1540
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x1eb0
movq -0x28(%rbp), %rdi
callq 0x20b0
movq -0x30(%rbp), %rdi
callq 0x20b0
movq 0x3ab9(%rip), %rdi      # 0x4fd0
leaq 0x1b2e(%rip), %rsi      # 0x304c
callq 0x10a0
movq %rax, %rdi
movq 0x3a93(%rip), %rsi      # 0x4fc0
callq 0x10b0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: brianwu02[P]ImageProcessing/briansFunctions.cpp
// Function: floatCopyToBuffer(imageS*, int, int, float*)
void floatCopyToBuffer(imageP I1, int row, int bufRowsRequired, float *buffer) {
    int height = I1->height;
    int width = I1->width;
    unsigned char *in;
    float *ptr;
    in = I1->image;

    int bufStartIndex = (row % bufRowsRequired) * width;

    ptr = &buffer[bufStartIndex+1];
    for (int x=0; x<width; x++) {
        ptr[0] = in[row*width+x];
        ptr++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
imull -0x20(%rbp), %edx
movl %edx, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2592
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl -0x20(%rbp), %edx
imull %edx, %ecx
movl -0x38(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x254e
popq %rbp
retq
nopw %cs:(%rax,%rax)