LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_decode(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::run_length_decode(vector<int> encoded) {
    int n = encoded.size();
    vector<int> decoded;
    decoded.reserve(n); // Heuristic; reserve some space for the data

    vector<int>::iterator viter = encoded.begin(), data_end = encoded.end();
    while (viter != data_end) {
        int run_int = *(viter++);
        int run_count = 1;
        while (*viter == run_int && run_count < RUN_MIN && viter != data_end) {
            ++viter;
            ++run_count;
        }
        if (run_count == RUN_MIN) run_count += *(viter++);
        for (int i=0; i<run_count; ++i) decoded.push_back(run_int);
    }
    
    return decoded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq %rax, %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x90a0
movq -0x70(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x8d20
movq -0x70(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9100
jmp 0x4b01
movq -0x80(%rbp), %rdi
callq 0x8dd0
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x8e80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8e40
testb $0x1, %al
jne 0x4b31
jmp 0x4c1b
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x8e00
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8eb0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8eb0
movl (%rax), %ecx
xorl %eax, %eax
cmpl -0x44(%rbp), %ecx
movb %al, -0x81(%rbp)
jne 0x4b8e
xorl %eax, %eax
cmpl $0x4, -0x54(%rbp)
movb %al, -0x81(%rbp)
jge 0x4b8e
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8e40
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x4b9a
jmp 0x4bc5
leaq -0x38(%rbp), %rdi
callq 0x8f00
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4b55
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8f20
jmp 0x4c3b
cmpl $0x4, -0x54(%rbp)
jne 0x4beb
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x8e00
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8eb0
movl (%rax), %eax
addl -0x54(%rbp), %eax
movl %eax, -0x54(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x54(%rbp), %eax
jge 0x4c16
movq -0x70(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x8d40
jmp 0x4c09
jmp 0x4c0b
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x4bf2
jmp 0x4b1b
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x4c2e
movq -0x70(%rbp), %rdi
callq 0x8f20
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::frame_diff_decompress(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::frame_diff_decompress(vector<int> compressed)
{
  vector<int> decompressed;
  int x = compressed[0], y = compressed[1], l = compressed[2], q, r;

  decompressed.push_back(x);
  decompressed.push_back(y);
  decompressed.push_back(l);

  for(int x_ind = 0; x_ind < x; x_ind++)
    for(int y_ind = 0; y_ind < y; y_ind++)
    {
      q = compressed[3 + 2 * (x_ind * y + y_ind)];
      r = compressed[3 + 2 * (x_ind * y + y_ind) + 1];
      decompressed.push_back(q * 256 + r);
    }

  return decompressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8d20
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8db0
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x1, %esi
callq 0x8db0
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x2, %esi
callq 0x8db0
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x28(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x8d40
jmp 0x52f3
movq -0x50(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x8d40
jmp 0x5302
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8d40
jmp 0x5311
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x53d2
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x53c2
movq -0x58(%rbp), %rdi
movl -0x40(%rbp), %ecx
movl -0x24(%rbp), %eax
imull %eax, %ecx
movl -0x44(%rbp), %eax
addl %eax, %ecx
movl %ecx, %eax
leal 0x3(%rax,%rax), %eax
movslq %eax, %rsi
callq 0x8db0
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x40(%rbp), %ecx
movl -0x24(%rbp), %eax
imull %eax, %ecx
movl -0x44(%rbp), %eax
addl %eax, %ecx
movl %ecx, %eax
leal 0x4(%rax,%rax), %eax
movslq %eax, %rsi
callq 0x8db0
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movl -0x30(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x8ed0
jmp 0x539e
jmp 0x53a0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x532b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8f20
jmp 0x53ef
jmp 0x53c4
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x5318
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x53e5
movq -0x50(%rbp), %rdi
callq 0x8f20
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2380
nopl (%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::compute_diffs(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::compute_diffs(vector<int> data) {
    vector<int> diffs;
    
    int x = data[0];
    int y = data[1];
    int L = data[2];
    
    vector<int>::iterator viter = data.begin();
    viter++;
    viter++;
    viter++;
    
    for (int x_ind=0; x_ind < x; ++x_ind) {
        for (int y_ind=0; y_ind < y; ++y_ind) {
            int val = data[3 + L * (x_ind*y + y_ind)];
                        
            for (int L_ind=1; L_ind < L; ++L_ind) {
                int diff = data[3 + L * (x_ind*y + y_ind) + L_ind] - val;
                val = diff + val;
                diffs.push_back(diff);
            }
        }
    }
    
    return diffs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8d20
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8db0
movq -0x78(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x1, %esi
callq 0x8db0
movq -0x78(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x2, %esi
callq 0x8db0
movq -0x78(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0x8dd0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x8e00
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x8e00
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x8e00
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5a76
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5a66
movq -0x78(%rbp), %rdi
movl -0x28(%rbp), %eax
movl -0x4c(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x50(%rbp), %ecx
imull %ecx, %eax
addl $0x3, %eax
movslq %eax, %rsi
callq 0x8db0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl $0x1, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5a56
movq -0x78(%rbp), %rdi
movl -0x28(%rbp), %edx
movl -0x4c(%rbp), %eax
movl -0x24(%rbp), %ecx
imull %ecx, %eax
movl -0x50(%rbp), %ecx
addl %ecx, %eax
imull %eax, %edx
movl -0x58(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x3(%rax,%rcx), %eax
movslq %eax, %rsi
callq 0x8db0
movq -0x88(%rbp), %rdi
movl (%rax), %eax
movl -0x54(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl -0x54(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x54(%rbp)
leaq -0x5c(%rbp), %rsi
callq 0x8d40
jmp 0x5a2f
jmp 0x5a31
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x59d5
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x8f20
jmp 0x5a99
jmp 0x5a58
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x599e
jmp 0x5a68
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x598b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5a8c
movq -0x88(%rbp), %rdi
callq 0x8f20
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::encode_positive(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::encode_positive(vector<int> nonpositive) {
    vector<int> positive;
    positive.reserve(nonpositive.size());
    
    for (vector<int>::iterator viter = nonpositive.begin(); viter != nonpositive.end(); ++viter) {
        int val = *viter;
        if (val == 0) positive.push_back(0);
        else if (val > 0) positive.push_back(2*val - 1);
        else positive.push_back(-2*val);
    }
    return positive;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8d20
movq -0x60(%rbp), %rdi
callq 0x90a0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x9100
jmp 0x5af3
movq -0x60(%rbp), %rdi
callq 0x8dd0
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rdi
callq 0x8e80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8e40
testb $0x1, %al
jne 0x5b23
jmp 0x5bb6
leaq -0x38(%rbp), %rdi
callq 0x8eb0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x5b66
movq -0x58(%rbp), %rdi
movl $0x0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x8ed0
jmp 0x5b4d
jmp 0x5ba6
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8f20
jmp 0x5bd3
cmpl $0x0, -0x44(%rbp)
jle 0x5b89
movq -0x58(%rbp), %rdi
movl -0x44(%rbp), %ecx
movl %ecx, %eax
leal -0x1(%rax,%rax), %eax
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x8ed0
jmp 0x5b87
jmp 0x5ba4
movq -0x58(%rbp), %rdi
movl -0x44(%rbp), %eax
addl %eax, %eax
negl %eax
movl %eax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x8ed0
jmp 0x5ba2
jmp 0x5ba4
jmp 0x5ba6
jmp 0x5ba8
leaq -0x38(%rbp), %rdi
callq 0x8f00
jmp 0x5b00
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5bc9
movq -0x58(%rbp), %rdi
callq 0x8f20
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::decode_positive(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::decode_positive(vector<int> positive) {
    vector<int> nonpositive;
    nonpositive.reserve(positive.size());
    
    for (vector<int>::iterator viter = positive.begin(); viter != positive.end(); ++viter) {
        int val = *viter;
        if (val % 2 == 1) nonpositive.push_back((val+1) / 2);
        else nonpositive.push_back(-val/2);
    }
    return nonpositive;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8d20
movq -0x60(%rbp), %rdi
callq 0x90a0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x9100
jmp 0x5c23
movq -0x60(%rbp), %rdi
callq 0x8dd0
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rdi
callq 0x8e80
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8e40
testb $0x1, %al
jne 0x5c53
jmp 0x5ce2
leaq -0x38(%rbp), %rdi
callq 0x8eb0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x5cb0
movq -0x58(%rbp), %rdi
movl -0x44(%rbp), %ecx
movl %ecx, %edx
incl %edx
movl %ecx, %eax
shrl $0x1f, %edx
movl %edx, %ecx
leal 0x1(%rax,%rcx), %eax
sarl %eax
movl %eax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x8ed0
jmp 0x5c97
jmp 0x5cd2
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8f20
jmp 0x5cff
movq -0x58(%rbp), %rdi
movl -0x44(%rbp), %ecx
movl %ecx, %eax
negl %eax
shrl $0x1f, %eax
subl %ecx, %eax
sarl %eax
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x8ed0
jmp 0x5cd0
jmp 0x5cd2
jmp 0x5cd4
leaq -0x38(%rbp), %rdi
callq 0x8f00
jmp 0x5c30
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5cf5
movq -0x58(%rbp), %rdi
callq 0x8f20
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2380
nopl (%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_encode(int*, int)
int *DATCompression::run_length_encode(int *data, int n) {
    vector<int> encoded;
    int *rle;
    encoded.reserve(n); // Heuristic; reserve enough space for the data
    
    int i=0;
    while (i < n) {
        int run_int = data[i];
        int run_count = 1;
        ++i;
        while (i < n && data[i] == run_int && run_count < RUN_MAX) {
            ++run_count;
            ++i;
        }
        for (int j=0; j<run_count && j<RUN_MIN; ++j) encoded.push_back(run_int);
        if (run_count >= RUN_MIN) encoded.push_back(run_count - RUN_MIN);
    }
    
    rle = (int *) calloc(encoded.size()+1, sizeof(encoded));
    rle[0] = n;
    copy(encoded.begin(), encoded.end(), rle+1);
    
    return rle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8d20
movq -0x70(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9100
jmp 0x5d42
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5e41
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rbp)
movl $0x1, -0x50(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x71(%rbp)
jge 0x5da2
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
cmpl -0x4c(%rbp), %ecx
movb %al, -0x71(%rbp)
jne 0x5da2
cmpl $0x103, -0x50(%rbp)     # imm = 0x103
setl %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x5dab
jmp 0x5dd9
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5d73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8f20
jmp 0x5ec0
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %ecx
xorl %eax, %eax
cmpl -0x50(%rbp), %ecx
movb %al, -0x72(%rbp)
jge 0x5df7
cmpl $0x4, -0x54(%rbp)
setl %al
movb %al, -0x72(%rbp)
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x5e00
jmp 0x5e1c
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x8d40
jmp 0x5e0f
jmp 0x5e11
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x5de0
cmpl $0x4, -0x50(%rbp)
jl 0x5e3c
movl -0x50(%rbp), %eax
addl $-0x4, %eax
movl %eax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8ed0
jmp 0x5e3a
jmp 0x5e3c
jmp 0x5d49
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x90a0
movq %rax, %rdi
incq %rdi
movl $0x18, %esi
callq 0x2150
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
callq 0x8dd0
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x8e80
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdx
addq $0x4, %rdx
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x9200
jmp 0x5e9c
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8f20
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_decode(int*)
int *DATCompression::run_length_decode(int *encoded) {
    int n = encoded[0];
    int *decoded = (int *) calloc(n, sizeof(int));

    int cur_ind = 1;
    int total_count = 0;
    while (total_count < n) {
        int run_int = encoded[cur_ind++];
        int run_count = 1;
        while (encoded[cur_ind] == run_int && run_count < RUN_MIN) {
            ++cur_ind;
            ++run_count;
        }
        if (run_count == RUN_MIN) run_count += encoded[cur_ind++];
        for (int i=0; i<run_count; ++i) decoded[total_count++] = run_int;
    }
    
    return decoded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5fc8
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
cmpl -0x2c(%rbp), %ecx
movb %al, -0x35(%rbp)
jne 0x5f53
cmpl $0x4, -0x30(%rbp)
setl %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x5f5c
jmp 0x5f70
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5f34
cmpl $0x4, -0x30(%rbp)
jne 0x5f91
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x5fc3
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5f98
jmp 0x5f09
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::burrows_wheeler_encode(int*, int)
int *DATCompression::burrows_wheeler_encode(int *data, int n) {
    SuffixArray sa(data, n);
    
    int *bwt = (int *) calloc(n+4, sizeof(int));
    long int dollar_ind;
    bwt[0] = data[n-1];
    
    for (int i=0; i<n; ++i) {
        if (sa[i] == 0) {
            bwt[i+1] = INT_MIN;
            dollar_ind = i + 1;
        }
        else bwt[i+1] = data[sa[i] - 1];
    }
    
    bwt[n+1] = dollar_ind / (256*256);
    bwt[n+2] = (dollar_ind / 256) % 256;
    bwt[n+3] = dollar_ind % 256;
    
    return bwt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x6780
movl -0x14(%rbp), %eax
addl $0x4, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x60e1
movl -0x44(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x9260
movl %eax, -0x58(%rbp)
jmp 0x6054
movl -0x58(%rbp), %eax
cmpl $0x0, %eax
jne 0x6098
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl $0x80000000, (%rax,%rcx,4) # imm = 0x80000000
movl -0x44(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
jmp 0x60d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9280
jmp 0x6162
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x44(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x9260
movl %eax, -0x5c(%rbp)
jmp 0x60b1
movq -0x68(%rbp), %rax
movl -0x5c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x60d3
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x6037
movq -0x40(%rbp), %rax
movl $0x10000, %ecx          # imm = 0x10000
cqto
idivq %rcx
movl %eax, %edx
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9280
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2380
nopl (%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: DATCompression::burrows_wheeler_decode(int*, int)
int *DATCompression::burrows_wheeler_decode(int *data, int n) {
    long int dollar_pos = 256*256*data[n+1] + 256*data[n+2] + data[n+3];
    int bwt_size = n + 1;
    
    pair<int,int> *f = (pair<int,int> *) calloc(bwt_size, sizeof(pair<int,int>));
    int *t = (int *) calloc(bwt_size, sizeof(int));
    int *s = (int *) calloc(n, sizeof(int));
    
    for (int i=0; i<bwt_size; ++i) f[i] = pair<int,int>(data[i], i);
    stable_sort(f, f + bwt_size, pair_comparator);
    
    for (int i=0; i<bwt_size; ++i) t[f[i].second] = i;
    free(f);
    
    int last_t = dollar_pos;
    for (int i=1; i<=n; ++i) {
        last_t = t[last_t];
        s[n-i] = data[last_t];
    }
    free(t);
    
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
shll $0x10, %eax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
addl $0x3, %edx
movslq %edx, %rdx
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
movl $0x8, %esi
callq 0x2150
movq %rax, -0x30(%rbp)
movslq -0x24(%rbp), %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x628e
movq -0x10(%rbp), %rsi
movslq -0x44(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq -0x4c(%rbp), %rdi
leaq -0x44(%rbp), %rdx
callq 0x9380
movq -0x30(%rbp), %rdi
movslq -0x44(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x4c(%rbp), %rsi
callq 0x93b0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x6247
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x118(%rip), %rdx      # 0x6190
callq 0x93e0
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x62de
movl -0x50(%rbp), %edx
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x50(%rbp), %rsi
movslq 0x4(%rcx,%rsi,8), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x62b4
movq -0x30(%rbp), %rdi
callq 0x22a0
movq -0x20(%rbp), %rax
movl %eax, -0x54(%rbp)
movl $0x1, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x6331
movq -0x38(%rbp), %rax
movslq -0x54(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movslq -0x54(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x58(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x62f5
movq -0x38(%rbp), %rdi
callq 0x22a0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: SuffixArray::SuffixArray(std::vector<int, std::allocator<int>>*)
SuffixArray::SuffixArray(vector<int> *data) {
    n = data->size();    
    s = (int *) calloc(n + 3, sizeof(int));

    copy(data->begin(), data->end(), s);
    
    prepareSuffixArray();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl (%rax), %eax
addl $0x3, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x8dd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e80
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9200
movq -0x28(%rbp), %rdi
callq 0x6670
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: SuffixArray::prepareSuffixArray()
void SuffixArray::prepareSuffixArray() {
    // Add 3 trailing zeroes for skew algorithm
    int i;
    int *cur_data_elt = s + n;
    *cur_data_elt = 0; ++cur_data_elt;
    *cur_data_elt = 0; ++cur_data_elt;
    *cur_data_elt = 0; ++cur_data_elt;
    
    sa = (int *) calloc(n, sizeof(int));
    
    // Suffix array computation requires values in [1,256] instead of [0,255]
    for (i=0; i<n; ++i) ++s[i];
    doSuffixArrayComputation(s, sa, n, 256);
    for (i=0; i<n; ++i) --s[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rcx
movslq (%rax), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x0, (%rcx)
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x0, (%rcx)
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x0, (%rcx)
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movslq (%rax), %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6722
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x66f7
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rsi
movq 0x8(%rdi), %rdx
movl (%rdi), %ecx
movl $0x100, %r8d            # imm = 0x100
callq 0x67e0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x676d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6742
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: SuffixArray::SuffixArray(int*, int)
SuffixArray::SuffixArray(int *data, int _n) {
    n = _n;
    
    s = (int *) calloc(n + 3, sizeof(int));
    memcpy(s, data, n * (sizeof(int)));
    
    prepareSuffixArray();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl (%rax), %eax
addl $0x3, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x2150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movslq (%rax), %rdx
shlq $0x2, %rdx
callq 0x21d0
movq -0x20(%rbp), %rdi
callq 0x6670
addq $0x20, %rsp
popq %rbp
retq
// File: dgboy2000[P]compress/compress.cpp
// Function: SuffixArray::print()
void SuffixArray::print() {
    for (int i=0; i<(n+3); ++i) {
        printf("s[%d] = %d\n", i, s[i]);
    }
    for (int i=0; i<n; ++i) {
        printf("sa[%d] = %d\n", i, sa[i]);
    }
}

// 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
movl (%rcx), %ecx
addl $0x3, %ecx
cmpl %ecx, %eax
jge 0x70d6
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x9059(%rip), %rdi      # 0x1011d
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x709b
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7113
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %esi
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x9028(%rip), %rdi      # 0x10129
movb $0x0, %al
callq 0x2040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x70dd
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: SuffixArray::radixPass(int*, int*, int*, int, int)
void SuffixArray::radixPass(int* a, int* b, int* r, int n, int K)
{// count occurrences
    int* c = new int[K + 1]; // counter array
    for (int i = 0; i <= K; i++) c[i] = 0; // reset counters
    for (int i = 0; i < n; i++) c[r[a[i]]]++; // count occurrences
    for (int i = 0, sum = 0; i <= K; i++) // exclusive prefix sums
    {int t = c[i]; c[i] = sum; sum += t; }
    for (int i = 0; i < n; i++) b[c[r[a[i]]]++] = a[i]; // sort
    delete [] c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x7196
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7174
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x71d1
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq -0x38(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x719d
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x7217
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl -0x40(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x71df
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x726c
movq -0x10(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdi
movslq -0x48(%rbp), %r8
movslq (%rdi,%r8,4), %rdi
movslq (%rcx,%rdi,4), %rdi
movl (%rsi,%rdi,4), %ecx
movl %ecx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x721e
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x7283
movq -0x50(%rbp), %rdi
callq 0x22e0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: test_suffix_arrays()
void test_suffix_arrays() {
    int len = 9;
    int word[] = {1, 2, 3, 4, 5, 4, 3, 2, 1};
    int true_suffixes[] = {8, 0, 7, 1, 6, 2, 5, 3, 4};
    
    SuffixArray sa(word, len);
    int *suffixes = sa.getSuffixArray();
    
    
    for (int i=0; i<len; ++i) {
        if (suffixes[i] == true_suffixes[i]) {
            //printf("CORRECT: True suffix SA[%d] = %d\n", i, suffixes[i]);
        } else {
            printf("FAIL: True suffix SA[%d] is %d but found %d\n", i, true_suffixes[i], suffixes[i]);
            return;
        }
    }
    printf("PASS: suffix array is correct\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x9, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x9363(%rip), %rsi      # 0x10610
movl $0x24, %edx
callq 0x21d0
leaq -0x60(%rbp), %rdi
leaq 0x937e(%rip), %rsi      # 0x10640
movl $0x24, %edx
callq 0x21d0
leaq -0x30(%rbp), %rsi
movl -0x4(%rbp), %edx
leaq -0x78(%rbp), %rdi
callq 0x6780
leaq -0x78(%rbp), %rdi
callq 0x7060
movq %rax, -0x80(%rbp)
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7382
movq -0x80(%rbp), %rax
movslq -0x84(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movslq -0x84(%rbp), %rcx
cmpl -0x60(%rbp,%rcx,4), %eax
jne 0x731f
jmp 0x736c
movslq -0x84(%rbp), %rcx
movl %ecx, %esi
movl -0x60(%rbp,%rcx,4), %edx
movq -0x80(%rbp), %rax
movl (%rax,%rcx,4), %ecx
leaq 0x8dfc(%rip), %rdi      # 0x10136
xorl %eax, %eax
callq 0x2040
jmp 0x7343
movl $0x1, -0x98(%rbp)
jmp 0x739c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9280
jmp 0x73ae
jmp 0x736e
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x72f3
leaq 0x8dda(%rip), %rdi      # 0x10163
xorl %eax, %eax
callq 0x2040
jmp 0x7392
movl $0x0, -0x98(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9280
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x2380
nopw (%rax,%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: investigate_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void investigate_file(string filename) {
    DATCompression dat;
    dat.init();
    
    printf("Investigating file %s\n", filename.c_str());
    
    vector<int> data = read_data(filename);
    dat.compute_diff_statistics(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x98c0
movq -0x98(%rbp), %rdi
callq 0x20e0
movq %rax, %rsi
leaq 0x79ba(%rip), %rdi      # 0x1055f
xorl %eax, %eax
callq 0x2040
movq -0x98(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x20f0
movq -0x90(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x80a0
jmp 0x8bd5
leaq -0x48(%rbp), %rdi
callq 0x2130
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8f80
jmp 0x8bf0
leaq -0x70(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x6350
jmp 0x8c06
leaq -0x70(%rbp), %rdi
callq 0x8f20
leaq -0x88(%rbp), %rdi
callq 0x8f20
leaq -0x28(%rbp), %rdi
callq 0x8f20
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2130
jmp 0x8c73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8c6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x8f20
leaq -0x28(%rbp), %rdi
callq 0x8f20
movq -0x50(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: dgboy2000[P]compress/compress.cpp
// Function: main
int main() {
    test_suffix_arrays();
    test_bwt();
    test_rle();
    
    // investigate_file("data/B28-39_100_100_acq_0007.tab");
    
    // test_compression_on_file("data/test.tab");

    test_compression_on_file("data/B28-39_100_100_acq_0007.tab");
    // test_compression_on_file("data/B28-39_100_100_acq_0400.tab");
    //test_compression_on_file("data/B28-39_1600_1000_acq_0007.tab");
    // test_compression_on_file("data/B28-39_1600_1000_acq_0400.tab");
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
callq 0x7290
callq 0x73c0
callq 0x7bf0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2390
movq -0x48(%rbp), %rdx
leaq 0x78c0(%rip), %rsi      # 0x10576
leaq -0x28(%rbp), %rdi
callq 0x9d20
jmp 0x8cc1
leaq -0x28(%rbp), %rdi
callq 0x8690
jmp 0x8ccc
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x2260
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8d09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x2260
movq -0x38(%rbp), %rdi
callq 0x2380
nopl (%rax,%rax)
// File: syusui-s[P]old_rpn_language/strfunc.cpp
// Function: delsp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string delsp(std::string input){
	//str+=(std::string)" ";
	input.insert(input.length()," ");
	while(1){
		if(input.find("  ",0)==std::string::npos) break;
		input.erase(input.find("  ",0),1);
	}
	if(input[0]==' ') input.erase(0,1);
	#ifdef DEBUG
	std::cout << input << std::endl;
	#endif

	return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdi, %rax
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3350
movq -0x18(%rbp), %rdi
movq %rax, %rsi
leaq 0x6a0c(%rip), %rdx      # 0xa005
callq 0x30a0
movq -0x18(%rbp), %rdi
leaq 0x69fb(%rip), %rsi      # 0xa004
xorl %eax, %eax
movl %eax, %edx
callq 0x3420
cmpq $-0x1, %rax
jne 0x361a
jmp 0x3641
movq -0x18(%rbp), %rdi
leaq 0x69df(%rip), %rsi      # 0xa004
xorl %eax, %eax
movl %eax, %edx
callq 0x3420
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x3090
jmp 0x35fe
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x3668
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x3090
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x3140
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: syusui-s[P]old_rpn_language/strfunc.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::list<std::string> split(std::string input){
	int i,pos,n=(int)input.length();
	std::list<std::string> output;
	
	pos = 0;
	for(i=0;i<n;i++){
		if(input[i]==' '){
			output.push_back(input.substr(i-pos,pos));
			#if MYDEBUG
			std::cout << input.substr(i-pos,pos) << std::endl;
			#endif
			pos = 0;
			continue;
		}
		pos++;
	}
	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3350
movq -0x58(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x37a0
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x376e
movq -0x68(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3430
movq %rax, -0x70(%rbp)
jmp 0x36e8
movq -0x70(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x3757
movq -0x68(%rbp), %rsi
movl -0x14(%rbp), %eax
movslq -0x18(%rbp), %rcx
movl %ecx, %edx
subl %edx, %eax
movslq %eax, %rdx
leaq -0x50(%rbp), %rdi
callq 0x3250
jmp 0x3711
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x37c0
jmp 0x3720
leaq -0x50(%rbp), %rdi
callq 0x3448
movl $0x0, -0x18(%rbp)
jmp 0x3760
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x378b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3448
jmp 0x378b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x36c9
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x3781
movq -0x58(%rbp), %rdi
callq 0x3800
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3800
movq -0x28(%rbp), %rdi
callq 0x33b0
nopl (%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: is_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_num(std::string input){
	unsigned int i=0;
	bool rtn=true;
	if(!is_dig(input[0]) && input[0]!='-' && input[0]!='+') rtn = false;
	for(i=1;i<input.length();i++){
		if(!is_dig(input[i]) && !is_dec(input[i])){
			rtn=false;
			break;
		}
	}
	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x1, -0xd(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3e70
testb $0x1, %al
jne 0x40fe
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x40fe
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x40fe
movb $0x0, -0xd(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
callq 0x3350
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x4168
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3e70
testb $0x1, %al
jne 0x415b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3ea0
testb $0x1, %al
jne 0x415b
movb $0x0, -0xd(%rbp)
jmp 0x4168
jmp 0x415d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4105
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: is_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_int(std::string input){
	unsigned int i;

	if(input[1]=='.') return false;
	if(input[0]=='0' && input.length()>1){
		throw((std::string)"0から始まる整数値は表記できません。0を表記する場合は、0を1つのみ入力するようにしてください。");
	}
	if(!is_dig(input[0]) && input[0]!='-' && input[0]!='+') return false; // 一文字目が数字でも-,+でもなければ、false
	for(i=1;i<input.length();i++){
		if(!is_dig(input[i])) return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x1, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x41ab
movb $0x0, -0x1(%rbp)
jmp 0x42f8
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x425b
movq -0x30(%rbp), %rdi
callq 0x3350
cmpq $0x1, %rax
jbe 0x425b
movb $0x1, -0x25(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, -0x40(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x15(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x33c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x5e37(%rip), %rsi      # 0xa040
callq 0x9180
jmp 0x4210
movq -0x48(%rbp), %rdi
movb $0x0, -0x25(%rbp)
leaq 0x9b69(%rip), %rsi      # 0xdd88
movq 0x9d92(%rip), %rdx      # 0xdfb8
callq 0x3390
jmp 0x430c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x3280
testb $0x1, -0x25(%rbp)
jne 0x424d
jmp 0x4256
movq -0x48(%rbp), %rdi
callq 0x3190
jmp 0x4303
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3e70
testb $0x1, %al
jne 0x42a4
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x42a4
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x42a4
movb $0x0, -0x1(%rbp)
jmp 0x42f8
movl $0x1, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x50(%rbp)
callq 0x3350
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x42f4
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3e70
testb $0x1, %al
jne 0x42e7
movb $0x0, -0x1(%rbp)
jmp 0x42f8
jmp 0x42e9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42ab
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33b0
nopl (%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: is_float(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_float(std::string input){
	unsigned int i;
	bool dec=false;

	for(i=0;i<input.length();i++){
		if(is_dec(input[i]) && dec){
			throw((std::string)"小数点を2個以上指定することはできません。");
			return false;
		}
		if(!is_dig(input[i]) && !is_dec(input[i])) return false;
		if(is_dec(input[i])) dec=true;

		if(dec && input.length()==1){
			//「.」のみの小数は扱えません
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movb $0x0, -0x15(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x3350
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x447d
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3ea0
testb $0x1, %al
jne 0x436a
jmp 0x43f8
testb $0x1, -0x15(%rbp)
je 0x43f8
movb $0x1, -0x25(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x33c0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x5d23(%rip), %rsi      # 0xa0c9
callq 0x9180
jmp 0x43ad
movq -0x50(%rbp), %rdi
movb $0x0, -0x25(%rbp)
leaq 0x99cc(%rip), %rsi      # 0xdd88
movq 0x9bf5(%rip), %rdx      # 0xdfb8
callq 0x3390
jmp 0x4495
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x3280
testb $0x1, -0x25(%rbp)
jne 0x43ea
jmp 0x43f3
movq -0x50(%rbp), %rdi
callq 0x3190
jmp 0x448c
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3e70
testb $0x1, %al
jne 0x4432
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3ea0
testb $0x1, %al
jne 0x4432
movb $0x0, -0x1(%rbp)
jmp 0x4481
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3ea0
testb $0x1, %al
jne 0x444e
jmp 0x4452
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
je 0x446d
movq -0x30(%rbp), %rdi
callq 0x3350
cmpq $0x1, %rax
jne 0x446d
movb $0x0, -0x1(%rbp)
jmp 0x4481
jmp 0x446f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x432b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: is_alphastr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_alphastr(std::string input){
	unsigned int i;

	for(i=0;i<input.length();i++){
		if(!is_alphabet(input[i])){
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x3350
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4500
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %edi
callq 0x3f20
testb $0x1, %al
jne 0x44f3
movb $0x0, -0x1(%rbp)
jmp 0x4504
jmp 0x44f5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x44b7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop