LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ctSkennerton[P]fxtract/util/bloom.c
// Function: ovfl_inc
static void
ovfl_inc(BLOOM *bp, int point)
{
    int i = bp->ovfl_limit;
    if (i <= bp->ovfl_count * 5 / 4) {
        // Double the hash table size:
        OVFL *oldp = bp->ovfl;
        bp->ovfl_limit += bp->ovfl_limit + 1;
        bp->ovfl = (OVFL *) calloc(bp->ovfl_limit, sizeof(OVFL));
        for (; i >= 0; --i)
            bp->ovfl[ovfl_find(bp, oldp[i].point)] = oldp[i];
        free(oldp);
    }

    i = ovfl_find(bp, point);
    if (!bp->ovfl[i].count++)
        bp->ovfl[i].point = point, bp->ovfl_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
imull $0x5, 0x24(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jg 0x3d2c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rdi
movl $0x8, %esi
callq 0x3130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpl $0x0, -0x10(%rbp)
jl 0x3d23
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,8), %esi
callq 0x4250
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movq -0x18(%rbp), %rdx
movslq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3cd9
movq -0x18(%rbp), %rdi
callq 0x3230
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4250
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, 0x4(%rcx,%rdx,8)
cmpl $0x0, %eax
jne 0x3d78
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_del
void
bloom_del(BLOOM *bp, char const *hash)
{
    int bitoff;
    FOR_CHUNKS(bitoff, bp) {
        int pt = CHUNK(bp, hash, bitoff);
        if (point_val(bp, pt) < bp->point_max || ovfl_dec(bp, pt))
            point_dec(bp, pt);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jg 0x3e01
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3bd0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3c10
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jl 0x3de4
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3e10
cmpl $0x0, %eax
je 0x3df0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3f10
jmp 0x3df2
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3d97
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/bloom.c
// Function: ovfl_dec
static int
ovfl_dec(BLOOM *bp, int point)
{
    int i = ovfl_find(bp, point);
    if (!  bp->ovfl[i].count) return 1;
    if (!--bp->ovfl[i].count) {
        // .count has gone from 1 to 0: the ovfl[] entry is dead,
        //  so higher entries may need to shift down.
        --bp->ovfl_count;
        while (bp->ovfl[i = (i + 1) & bp->ovfl_limit].count) {
            int j = ovfl_find(bp, bp->ovfl[i].point);
            if (j != i)
                bp->ovfl[j] = bp->ovfl[i], bp->ovfl[i].count = 0;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4250
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, 0x4(%rax,%rcx,8)
jne 0x3e4d
movl $0x1, -0x4(%rbp)
jmp 0x3efe
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0x18(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rcx,%rdx,8)
cmpl $0x0, %eax
jne 0x3ef7
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rdx
andl 0x20(%rdx), %ecx
movl %ecx, -0x18(%rbp)
movslq %ecx, %rcx
cmpl $0x0, 0x4(%rax,%rcx,8)
je 0x3ef5
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,8), %esi
callq 0x4250
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x3ef3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq 0x28(%rdx), %rdx
movslq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, 0x4(%rax,%rcx,8)
jmp 0x3e7a
jmp 0x3ef7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_chk
int
bloom_chk(BLOOM const*bp, char const *hash)
{
    int bitoff;
    FOR_CHUNKS(bitoff, bp)
        if (!point_val(bp, CHUNK(bp, hash, bitoff)))
            return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jg 0x3fad
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x3bd0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x3c10
cmpl $0x0, %eax
jne 0x3f9c
movl $0x0, -0x4(%rbp)
jmp 0x3fb4
jmp 0x3f9e
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f57
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/bloom.c
// Function: ovfl_find
static int
ovfl_find(BLOOM const*bp, int point)
{
    int i;
    for (i = point;; ++i) {
        i &= bp->ovfl_limit;
        if (!bp->ovfl[i].count || bp->ovfl[i].point == point)
            return i;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, 0x4(%rax,%rcx,8)
je 0x4295
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,8), %eax
cmpl -0xc(%rbp), %eax
jne 0x429a
movl -0x10(%rbp), %eax
popq %rbp
retq
jmp 0x429c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4261
nopw (%rax,%rax)
// File: TheZoq2[P]sweplusplus/sv.cpp
// Function: main
hel hufvud(hel arga, vidbränd dubbelpekare argv)
{
    bil i = 0;
    vidbränd dubbelpekare nuvarande = argv;

    medans (i < arga) {
        placeras(dereferera nuvarande);
        nuvarande++;
        i ökas_med_ett;
        om (i == 3) {
            uppfostra Barn("För många argument");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2421
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0x241c
movb $0x1, -0x55(%rbp)
movl $0x20, %edi
callq 0x2080
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x21b0
movq -0x60(%rbp), %rdx
leaq 0xc5e(%rip), %rsi       # 0x3004
leaq -0x40(%rbp), %rdi
callq 0x2440
jmp 0x23b1
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24f0
jmp 0x23c0
movq -0x68(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x29e1(%rip), %rsi      # 0x4db0
leaq 0x13a(%rip), %rdx       # 0x2510
callq 0x2190
jmp 0x2433
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2090
leaq -0x41(%rbp), %rdi
callq 0x2110
testb $0x1, -0x55(%rbp)
jne 0x2411
jmp 0x241a
movq -0x68(%rbp), %rdi
callq 0x20c0
jmp 0x242a
jmp 0x2345
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x21a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: eecs280staff[P]unit_test_framework/test/size_t_and_int.cpp
// Function: size_t_and_int()
TEST(size_t_and_int) {
  std::size_t s = 3u;
  int i1 = -1;
  int i2 = 3;
  ASSERT_NOT_EQUAL(s, i1);
  ASSERT_NOT_EQUAL(i1, s);
  ASSERT_EQUAL(s, i2);
  ASSERT_EQUAL(i2, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x3, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x3, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x7, %edx
leaq 0x5971(%rip), %rcx      # 0x9013
callq 0x4c10
leaq -0xc(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0x8, %edx
leaq 0x5970(%rip), %rcx      # 0x902b
callq 0x4d90
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x9, %edx
leaq 0x596f(%rip), %rcx      # 0x9043
callq 0x4f10
leaq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
movl $0xa, %edx
leaq 0x596a(%rip), %rcx      # 0x9057
callq 0x5080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: void unit_test_framework::Assertions::assert_not_equal<unsigned long&, int&>(unsigned long&, int&, int, char const*)
static void assert_not_equal(First&& first, Second&& second,
                                 int line_number,
                                 const char* assertion_text) {
      if (safe_equals<First, Second>::not_equals(first, second)) {
        return;
      }
      std::ostringstream reason;

      reason << "Values unexpectedly equal: ";
      Diagnostic::print(reason, first);
      reason << " == ";
      Diagnostic::print(reason, second);
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x51f0
testb $0x1, %al
jne 0x4c3d
jmp 0x4c46
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x32f0
movq -0x1d8(%rbp), %rdi
leaq 0x4404(%rip), %rsi      # 0x906b
callq 0x3210
jmp 0x4c6e
movq -0x8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x5220
jmp 0x4c80
leaq 0x4400(%rip), %rsi      # 0x9087
leaq -0x198(%rbp), %rdi
callq 0x3210
jmp 0x4c95
movq -0x10(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x5250
jmp 0x4ca7
movb $0x1, -0x1c9(%rbp)
movl $0x30, %edi
callq 0x3100
movq %rax, -0x1e0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3240
jmp 0x4cd4
movq -0x1e0(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x1c8(%rbp), %rsi
callq 0x5280
jmp 0x4cf0
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1c9(%rbp)
leaq 0x903b(%rip), %rsi      # 0xdd40
leaq 0x5b4(%rip), %rdx       # 0x52c0
callq 0x3390
jmp 0x4d8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x4d72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x4d59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3150
testb $0x1, -0x1c9(%rbp)
jne 0x4d64
jmp 0x4d70
movq -0x1e0(%rbp), %rdi
callq 0x31a0
jmp 0x4d72
leaq -0x198(%rbp), %rdi
callq 0x3080
movq -0x1a0(%rbp), %rdi
callq 0x33c0
nopw (%rax,%rax)
// File: IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::update_with_rule(void (*)(Grid&, unsigned int, unsigned int))
void Grid::update_with_rule(void (*rule)(Grid&, uint32_t x, uint32_t y)) {
  for (uint32_t y = 0; y < height; y++) {
    for (uint32_t x = 0; x < width; x++) {
      rule(*this, x, y);
    }
  }
  swap();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x33f5
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jae 0x33e8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x33c2
jmp 0x33ea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x33af
movq -0x20(%rbp), %rdi
callq 0x3410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::print()
void Grid::print() {
  for (uint32_t y = 0; y < height; y++) {
    for (uint32_t x = 0; x < width; x++) {
      std::cout << (get(x, y) == Tile::Alive ? '#' : '.');
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x352a
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jae 0x350c
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x3530
movb %al, %cl
movb $0x23, %al
movb $0x2e, %dl
movb %dl, -0x1a(%rbp)
cmpb $-0x1, %cl
movb %al, -0x19(%rbp)
je 0x34ef
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movq 0x4adf(%rip), %rdi      # 0x7fd8
movsbl %al, %esi
callq 0x2210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x34be
movq 0x4ac5(%rip), %rdi      # 0x7fd8
movq 0x4aae(%rip), %rsi      # 0x7fc8
callq 0x21b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34ab
addq $0x20, %rsp
popq %rbp
retq
// File: IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::count_neighbors(unsigned int, unsigned int, Tile, unsigned int)
uint32_t Grid::count_neighbors(uint32_t x, uint32_t y, Tile to_count,
                               uint32_t extent) {

  uint32_t min_x = std::max<int32_t>(x - extent, 0);
  uint32_t max_x = std::min<int32_t>(x + extent, width - 1);
  uint32_t min_y = std::max<int32_t>(y - extent, 0);
  uint32_t max_y = std::min<int32_t>(y + extent, height - 1);

  uint32_t count = 0;
  for (uint32_t _y = min_y; _y <= max_y; _y++) {
    for (uint32_t _x = min_x; _x <= max_x; _x++) {
      if (_x == x && _y == y) {
        continue;
      }
      if (get(_x, _y) == to_count) {
        count++;
      }
    }
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x3860
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x38a0
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x3860
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x34(%rbp)
movl -0x10(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x44(%rbp)
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
leaq -0x44(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x38a0
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x40(%rbp), %eax
ja 0x3708
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x28(%rbp), %eax
ja 0x36fb
movl -0x54(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x36d1
movl -0x50(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x36d1
jmp 0x36f0
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movl -0x50(%rbp), %edx
callq 0x3530
cmpb -0x11(%rbp), %al
jne 0x36ee
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x36f0
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x36b7
jmp 0x36fd
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x36a9
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: IsseW[P]bytepusher/src/grid/rules.cpp
// Function: game_of_life_rule(Grid&, unsigned int, unsigned int)
void game_of_life_rule(Grid& grid, uint32_t x, uint32_t y) {
  Tile tile = grid.get(x, y);
  uint32_t count = grid.count_neighbors(x, y);
  if (tile == Tile::Alive) {
    if (count < 2 || count > 3) {
      tile = Tile::Dead;
    }
  } else if (tile == Tile::Dead && count == 3) {
    tile = Tile::Alive;
  }
  grid.set(x, y, tile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3530
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl $0xff, %ecx
movl $0x1, %r8d
callq 0x35e0
movl %eax, -0x18(%rbp)
cmpb $-0x1, -0x11(%rbp)
jne 0x3d99
cmpl $0x2, -0x18(%rbp)
jb 0x3d93
cmpl $0x3, -0x18(%rbp)
jbe 0x3d97
movb $0x0, -0x11(%rbp)
jmp 0x3dab
cmpb $0x0, -0x11(%rbp)
jne 0x3da9
cmpl $0x3, -0x18(%rbp)
jne 0x3da9
movb $-0x1, -0x11(%rbp)
jmp 0x3dab
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movzbl -0x11(%rbp), %ecx
callq 0x3590
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: IsseW[P]bytepusher/src/grid/rules.cpp
// Function: water_sim_rule(Grid&, unsigned int, unsigned int)
void water_sim_rule(Grid& grid, uint32_t x, uint32_t y) {
  Tile tile = grid.get(x, y);
  if (tile == Tile::Alive) {
    if (grid.get(x, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x, y + 1, Tile::Alive);
    } else if (grid.get(x + 1, y) == Tile::Dead && grid.get(x + 1, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x + 1, y + 1, Tile::Alive);
    } else if (grid.get(x - 1, y) == Tile::Dead && grid.get(x - 1, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x - 1, y + 1, Tile::Alive);
    }
  }
  grid.set(x, y, tile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3530
movb %al, -0x11(%rbp)
cmpb $-0x1, -0x11(%rbp)
jne 0x3ed6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
callq 0x3530
cmpb $0x0, %al
jne 0x3e34
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
movl $0xff, %ecx
callq 0x3590
jmp 0x3ed4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x3530
cmpb $0x0, %al
jne 0x3e83
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
callq 0x3530
cmpb $0x0, %al
jne 0x3e83
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
movl $0xff, %ecx
callq 0x3590
jmp 0x3ed2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x3530
cmpb $0x0, %al
jne 0x3ed0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
callq 0x3530
cmpb $0x0, %al
jne 0x3ed0
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
movl $0xff, %ecx
callq 0x3590
jmp 0x3ed2
jmp 0x3ed4
jmp 0x3ed6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movzbl -0x11(%rbp), %ecx
callq 0x3590
addq $0x20, %rsp
popq %rbp
retq
nop
// File: IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::Renderer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, unsigned int, unsigned int)
Renderer::Renderer(
    const std::string& name, 
    uint32_t bw, uint32_t bh,
    uint32_t ww, uint32_t wh
):  bw{bw}, bh{bh},
    ww{ww}, wh{wh} 
{
    init_backend();
    SDL_CreateWindowAndRenderer(ww, wh, 0, &sdl_win, &sdl_rend);
    sdl_text = SDL_CreateTexture(sdl_rend, SDL_PIXELFORMAT_RGB332, SDL_TEXTUREACCESS_TARGET, bw, bh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, (%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x4(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x20(%rbp), %eax
movl %eax, 0xc(%rdi)
addq $0x38, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4260
callq 0x3ef0
jmp 0x3f91
movq -0x40(%rbp), %r8
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq %r8, %rcx
addq $0x28, %rcx
addq $0x30, %r8
xorl %edx, %edx
callq 0x2080
jmp 0x3faf
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x14110801, %esi       # imm = 0x14110801
movl $0x2, %edx
callq 0x22e0
movq %rax, -0x48(%rbp)
jmp 0x3fd3
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2d30
movq -0x28(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::finalize()
void Renderer::finalize(){
    SDL_UnlockTexture(sdl_text);
    SDL_SetRenderDrawColor(sdl_rend, 0, 0, 0, 0);
    SDL_RenderClear(sdl_rend);
    SDL_RenderCopy(sdl_rend, sdl_text, nullptr, nullptr);
    SDL_RenderPresent(sdl_rend);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x20(%rax), %rdi
callq 0x2260
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x2270
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x21a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x20(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::poll_events()
bool Renderer::poll_events(){
    SDL_Event event;
    while(SDL_PollEvent(&event)){
        if(meh)
            meh(event);
        switch(event.type){
        case SDL_QUIT:
            destroy();
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20e0
cmpl $0x0, %eax
je 0x41f3
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x42a0
testb $0x1, %al
jne 0x41c5
jmp 0x41d6
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
leaq -0x48(%rbp), %rsi
callq 0x42d0
movl -0x48(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
jne 0x41f1
jmp 0x41e2
movq -0x50(%rbp), %rdi
callq 0x4050
movb $0x0, -0x1(%rbp)
jmp 0x41f7
jmp 0x41a4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::setUp(unsigned int)
void TaskQueue::setUp(uint32_t max_capacity)
{
	this->tasks = new queue<Task*>();
	sem_init(&(this->lock),0,1);
	sem_init(&(this->unfinished_business),0,0);
	sem_init(&(this->space_available),0,max_capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x50, %edi
callq 0x2210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x6a80
jmp 0x61f2
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x21b0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x21b0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x21b0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x50, %esi
callq 0x2220
movq -0x18(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::clear()
void TaskQueue::clear()
{
	sem_wait(&(this->lock));
	while (!this->tasks->empty())
	{
		delete this->tasks->front();
		this->tasks->pop();

		sem_wait(&(this->unfinished_business)); // this will never block (well, it shouldn't...if it does, that's a logic error)
		sem_post(&(this->space_available));
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x20e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6ad0
xorb $-0x1, %al
testb $0x1, %al
jne 0x6321
jmp 0x6379
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6b20
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x6351
movq -0x18(%rbp), %rdi
callq 0x80b0
movq -0x18(%rbp), %rdi
movl $0x48, %esi
callq 0x2220
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6b40
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x20e0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x2340
jmp 0x630d
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::add(Task*)
void TaskQueue::add(Task* task)
{
	sem_wait(&(this->space_available));
	sem_wait(&(this->lock));
	this->tasks->push(task);
	sem_post(&(this->lock));
	sem_post(&(this->unfinished_business));
}

// 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)
addq $0x48, %rdi
callq 0x20e0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20e0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x6af0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2340
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x2340
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::get()
Task* TaskQueue::get()
{
	sem_wait(&(this->unfinished_business));
	sem_wait(&(this->lock));
	Task* temp_ptr = this->tasks->front();
	this->tasks->pop();
	sem_post(&(this->lock));
	sem_post(&(this->space_available));
	return temp_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x28, %rdi
callq 0x20e0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20e0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6b20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0x6b40
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2340
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x2340
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: ridgelab[P]Kmer-SSR/src/Task.cpp
// Function: Task::Task(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
Task::Task(const string &_identifier, const string &_sequence, uint32_t _global_pos, uint32_t _global_seq_length)
{
	this->identifier = _identifier;
	this->sequence = _sequence;
	this->global_pos = _global_pos;
	this->global_seq_length = _global_seq_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x22e0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22e0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2040
jmp 0x805f
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x2040
jmp 0x8072
movq -0x48(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x40(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x44(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2100
movq -0x38(%rbp), %rdi
callq 0x2100
movq -0x28(%rbp), %rdi
callq 0x2360
nop
// File: ridgelab[P]Kmer-SSR/src/Task.cpp
// Function: Task::equalTo(Task*) const
bool Task::equalTo(Task* other) const
{
	if (this->identifier != other->getID())
	{
		return false;
	}
	if (this->sequence != other->getSequence())
	{
		return false;
	}
	if (this->global_pos != other->getGlobalPosition())
	{
		return false;
	}
	if (this->global_seq_length != other->getGlobalSequenceLength())
	{
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8310
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8800
movb %al, -0x59(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2100
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x841a
jmp 0x8423
movb $0x0, -0x1(%rbp)
jmp 0x84ac
movq -0x68(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x8340
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8800
movb %al, -0x69(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2100
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x845e
jmp 0x8464
movb $0x0, -0x1(%rbp)
jmp 0x84ac
movq -0x68(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8390
movl %eax, %ecx
movl -0x7c(%rbp), %eax
cmpl %ecx, %eax
je 0x8486
movb $0x0, -0x1(%rbp)
jmp 0x84ac
movq -0x68(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x83b0
movl %eax, %ecx
movl -0x80(%rbp), %eax
cmpl %ecx, %eax
je 0x84a8
movb $0x0, -0x1(%rbp)
jmp 0x84ac
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dm4[P]huffman-homework/my_encode.cc
// Function: assignCLRecursive(int, char)
void assignCLRecursive(int index, char cl) {
    CLRecordEntry *entry = CLRecord[index];
    entry->cl = cl;
    if (entry->s1 < 0)
        assignCLRecursive(~entry->s1, cl + 1);
    if (entry->s2 < 0)
        assignCLRecursive(~entry->s2, cl + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xed24(%rip), %rdi      # 0x10120
callq 0x2280
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movb -0x5(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x1433
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl $-0x1, %edi
movsbl -0x5(%rbp), %eax
addl $0x1, %eax
movsbl %al, %esi
callq 0x13e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x1456
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
xorl $-0x1, %edi
movsbl -0x5(%rbp), %eax
addl $0x1, %eax
movsbl %al, %esi
callq 0x13e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: dm4[P]huffman-homework/my_encode.cc
// Function: buildSymbols()
void buildSymbols() {
    for (int i = CLRecord.size() - 1; i >= 0; i--) {
        CLRecordEntry *entry = CLRecord[i];
        if (entry->s1 >= 0) {
            Symbol *s = (Symbol *)malloc(sizeof(Symbol));
            s->cl = entry->cl;
            s->symbol = entry->s1;
            symbols.push_back(s);
        }
        if (entry->s2 >= 0) {
            Symbol *s = (Symbol *)malloc(sizeof(Symbol));
            s->cl = entry->cl;
            s->symbol = entry->s2;
            symbols.push_back(s);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xec81(%rip), %rdi      # 0x10120
callq 0x22a0
subq $0x1, %rax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x1566
movslq -0x4(%rbp), %rsi
leaq 0xec60(%rip), %rdi      # 0x10120
callq 0x2280
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x1510
movl $0x8, %edi
callq 0x1140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x5(%rax)
leaq 0xec31(%rip), %rdi      # 0x10138
leaq -0x18(%rbp), %rsi
callq 0x22c0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x1556
movl $0x8, %edi
callq 0x1140
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x5(%rax)
leaq 0xebeb(%rip), %rdi      # 0x10138
leaq -0x20(%rbp), %rsi
callq 0x22c0
jmp 0x1558
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x14ab
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dm4[P]huffman-homework/my_encode.cc
// Function: buildSymbolsCodeword()
void buildSymbolsCodeword() {
    unsigned int codeword = 0;
    symbols[0]->codeword = codeword;
    for (int i = 1; i < symbols.size(); i++) {
        int lengthDiff = symbols[i]->cl - symbols[i - 1]->cl;
        codeword += 1;
        codeword <<= lengthDiff;
        symbols[i]->codeword = codeword;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq 0xebac(%rip), %rdi      # 0x10138
xorl %eax, %eax
movl %eax, %esi
callq 0x2330
movl -0x10(%rbp), %ecx
movq (%rax), %rax
movl %ecx, (%rax)
movl $0x1, -0x8(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xeb85(%rip), %rdi      # 0x10138
callq 0x2350
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x1649
movslq -0x8(%rbp), %rsi
leaq 0xeb65(%rip), %rdi      # 0x10138
callq 0x2330
movq (%rax), %rax
movsbl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xeb46(%rip), %rdi      # 0x10138
callq 0x2330
movq %rax, %rcx
movl -0x20(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x4(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %ecx
movl -0x4(%rbp), %eax
shll %cl, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x8(%rbp), %rsi
leaq 0xeb0a(%rip), %rdi      # 0x10138
callq 0x2330
movl -0x1c(%rbp), %ecx
movq (%rax), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15a4
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Erkaman[P]spiky-anim/main.cpp
// Function: zeroPad[abi:cxx11](int, int)
std::string zeroPad(int n, int len) {
    string str = "";

    str = to_string(n);

    while(str.size() < len) {
        str = "0" + str;
    }

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2330
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x3db7(%rip), %rsi      # 0x6287
callq 0x3500
jmp 0x24d7
leaq -0x12(%rbp), %rdi
callq 0x2230
movl -0xc(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x35b0
jmp 0x24ee
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2280
leaq -0x48(%rbp), %rdi
callq 0x2140
movq -0x78(%rbp), %rdi
callq 0x2160
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2572
movq -0x78(%rbp), %rdx
leaq 0x3b0f(%rip), %rsi      # 0x6030
leaq -0x68(%rbp), %rdi
callq 0x36d0
jmp 0x252c
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2280
leaq -0x68(%rbp), %rdi
callq 0x2140
jmp 0x2504
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x2230
jmp 0x2592
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2140
jmp 0x2592
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2585
movq -0x78(%rbp), %rdi
callq 0x2140
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2320
nopl (%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_list.cpp
// Function: List::AppendHead(int const&)
void List::AppendHead(const int& value) {
  if(head_.get() == nullptr) {
    head_.reset(new List::Node());
    head_.get()->value = value;
    tail_ = head_.get();
  } else {
    List::Node* tmp = new List::Node();
    tmp->value = value;
    tmp->next = std::move(head_);
    head_.reset(tmp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1900
cmpq $0x0, %rax
jne 0x12e4
movl $0x10, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1960
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x1930
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x1900
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, 0x8(%rax)
callq 0x1900
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1339
movl $0x10, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1050
movq -0x38(%rbp), %rdi
callq 0x1960
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x1980
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1930
addq $0x40, %rsp
popq %rbp
retq
nop
// File: eschwabe[P]interview-practice/src/libds_list.cpp
// Function: List::AppendTail(int const&)
void List::AppendTail(const int& value) {
  if(head_.get() == nullptr) {
    head_.reset(new List::Node());
    head_.get()->value = value;
    tail_ = head_.get();
  } else {
    List::Node* tmp = new List::Node();
    tmp->value = value;
    tmp->next = nullptr;
    tail_->next.reset(tmp);
    tail_ = tail_->next.get();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1900
cmpq $0x0, %rax
jne 0x13c4
movl $0x10, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1960
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x1930
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x1900
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, 0x8(%rax)
callq 0x1900
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1435
movl $0x10, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1050
movq -0x38(%rbp), %rdi
callq 0x1960
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19b0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1930
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1900
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_list.cpp
// Function: List::RemoveHead()
int List::RemoveHead() {
  if(head_.get() == nullptr) {
    return -1;
  } else {
    int tmp = head_.get()->value;
    head_ = std::move(head_.get()->next);
    return tmp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1900
cmpq $0x0, %rax
jne 0x1468
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1492
movq -0x20(%rbp), %rdi
callq 0x1900
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x1900
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1980
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_list.cpp
// Function: List::RemoveTail()
int List::RemoveTail() {
  if(tail_ == nullptr) {
    return -1;
  } else if(head_.get() == tail_) {
    int tmp = tail_->value;
    tail_ = nullptr;
    head_.release();
    return tmp;
  } else {
    int tmp = tail_->value;
    Node* prev = nullptr;
    Node* current = head_.get();
    while(current != nullptr && current->next.get() != nullptr) {
      prev = current;
      current = current->next.get();
    }
    prev->next.release();
    tail_ = prev;
    return tmp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x14c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1576
movq -0x30(%rbp), %rdi
callq 0x1900
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x14fd
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq $0x0, 0x8(%rdi)
callq 0x19e0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1576
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x1900
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x153b
movq -0x28(%rbp), %rdi
callq 0x1900
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1544
jmp 0x155b
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1900
movq %rax, -0x28(%rbp)
jmp 0x151c
movq -0x20(%rbp), %rdi
callq 0x19e0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::init(int, int)
void ThresholdSolver::init(int readLength, int seedNum)
{
	this->seedNum = seedNum;
	vector< int > thresholdVec (seedNum);
	for(int i = 0; i < thresholdVec.size(); i++)
		thresholdVec[i] = readLength;
	this->thresholdVec = thresholdVec;
	this->frequencyVec.resize(thresholdVec.size(), -1);
	this->lengthVec.resize(thresholdVec.size(), 0);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x78(%rsp), %ecx
movl %ecx, 0xc8(%rax)
movslq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x4b30
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x9f80
jmp 0x7cdd
leaq 0x5f(%rsp), %rdi
callq 0x5210
movl $0x0, 0x48(%rsp)
movslq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5550
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x7d57
movl 0x7c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movslq 0x48(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xa000
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x7cef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x5210
jmp 0x7e05
movq 0x28(%rsp), %rdi
addq $0x450, %rdi            # imm = 0x450
leaq 0x60(%rsp), %rsi
callq 0xa020
jmp 0x7d6f
movq 0x28(%rsp), %rax
addq $0x480, %rax            # imm = 0x480
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5550
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
leaq 0x44(%rsp), %rdx
callq 0x45d0
jmp 0x7da5
movq 0x28(%rsp), %rax
addq $0x468, %rax            # imm = 0x468
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5550
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x0, 0x40(%rsp)
leaq 0x40(%rsp), %rdx
callq 0x45d0
jmp 0x7ddb
leaq 0x60(%rsp), %rdi
callq 0x48c0
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x48c0
movq 0x50(%rsp), %rdi
callq 0x35c0
nop
// File: CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::analyzeRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ThresholdSolver::analyzeRead(string read) {
	int minLength = tree.getHashLength();
	int maxLength = tree.getFullLength();

	int pos = 0;

	for (int i = 0; i < thresholdVec.size(); i++) {
		string seed = read.substr(pos, maxLength);

		tree.query(seed, thresholdVec[i]);
		frequencyVec[i] = tree.frequency();
		lengthVec[i] = tree.effectiveLength();
		pos += tree.effectiveLength();

		if (pos > read.length() - minLength)
			break;
	}
}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0xd0, %rdi
callq 0xe220
movq 0x40(%rsp), %rdi
movl %eax, 0xa4(%rsp)
addq $0xd0, %rdi
callq 0xe230
movl %eax, 0xa0(%rsp)
movl $0x0, 0x9c(%rsp)
movl $0x0, 0x98(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x450, %rdi            # imm = 0x450
callq 0x5550
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x80fe
movq 0x38(%rsp), %rsi
movslq 0x9c(%rsp), %rdx
movslq 0xa0(%rsp), %rcx
leaq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x32f0
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rsi
addq $0xd0, %rax
movq %rax, 0x28(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3150
jmp 0x7f8e
movq 0x40(%rsp), %rdi
addq $0x450, %rdi            # imm = 0x450
movslq 0x98(%rsp), %rsi
callq 0xa000
movq 0x28(%rsp), %rdi
movl (%rax), %edx
leaq 0x58(%rsp), %rsi
callq 0xe240
jmp 0x7fba
leaq 0x58(%rsp), %rdi
callq 0x31c0
movq 0x40(%rsp), %rdi
addq $0xd0, %rdi
callq 0xe4a0
movl %eax, 0x1c(%rsp)
jmp 0x7fdb
movq 0x40(%rsp), %rdi
addq $0x480, %rdi            # imm = 0x480
movslq 0x98(%rsp), %rsi
callq 0xa000
movl 0x1c(%rsp), %ecx
movq 0x40(%rsp), %rdi
movl %ecx, (%rax)
addq $0xd0, %rdi
callq 0xe480
movl %eax, 0x18(%rsp)
jmp 0x8011
movq 0x40(%rsp), %rdi
addq $0x468, %rdi            # imm = 0x468
movslq 0x98(%rsp), %rsi
callq 0xa000
movl 0x18(%rsp), %ecx
movq 0x40(%rsp), %rdi
movl %ecx, (%rax)
addq $0xd0, %rdi
callq 0xe480
movl %eax, 0x14(%rsp)
jmp 0x8047
movq 0x38(%rsp), %rdi
movl 0x14(%rsp), %eax
addl 0x9c(%rsp), %eax
movl %eax, 0x9c(%rsp)
movslq 0x9c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x34d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movslq 0xa4(%rsp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x80bc
movl $0x2, 0x48(%rsp)
jmp 0x80c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x80f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x31c0
jmp 0x80f2
movl $0x0, 0x48(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x31c0
movl 0x48(%rsp), %eax
testl %eax, %eax
je 0x80da
jmp 0x80d8
jmp 0x80fe
jmp 0x80dc
movl 0x98(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x98(%rsp)
jmp 0x7f1a
leaq 0x78(%rsp), %rdi
callq 0x31c0
jmp 0x8106
addq $0xb8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x35c0