LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: Translate(char const*, char const*)
void Translate(const char* input, const char* output)
{
    assert(input);

    Tree* tree = GetTreeFromFile(input);
    TreeDump(tree);
    FILE* translate = fopen(output, "w");
    assert(translate);

    fprintf(translate, "~ THIS FILE WAS GENERATED AUTOMATICLY\n"
                       "~ TREE TAKED FROM FILE '%s'          \n"
                       "~ CHECK FILE BEFORE COMPILING      \n\n", input);

    TranslateTree(tree, translate);

    DestructTree(tree);
    DeleteTree(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5fe9
jmp 0x6008
leaq 0x1200(%rip), %rdi      # 0x71f0
leaq 0x22ad(%rip), %rsi      # 0x82a4
movl $0x18, %edx
leaq 0x22be(%rip), %rcx      # 0x82c1
callq 0x2090
movq -0x8(%rbp), %rdi
callq 0x2630
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4020
movq -0x10(%rbp), %rdi
leaq 0x106c(%rip), %rsi      # 0x7095
callq 0x2100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x603b
jmp 0x605a
leaq 0x22aa(%rip), %rdi      # 0x82ec
leaq 0x225b(%rip), %rsi      # 0x82a4
movl $0x1d, %edx
leaq 0x226c(%rip), %rcx      # 0x82c1
callq 0x2090
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x228d(%rip), %rsi      # 0x82f6
movb $0x0, %al
callq 0x2140
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x60a0
movq -0x18(%rbp), %rdi
callq 0x4430
movq -0x18(%rbp), %rdi
callq 0x44c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateTree(Tree*, _IO_FILE*)
void TranslateTree(Tree* tree, FILE* file)
{
    assert(tree);
    assert(file);

    Node* node = tree->root;

    while (node != nullptr)
    {
        TranslateFunc(node->right, file);
        node = node->left;
        fprintf(file, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x60b9
jmp 0x60d8
leaq 0xf89(%rip), %rdi       # 0x7049
leaq 0x21dd(%rip), %rsi      # 0x82a4
movl $0x2b, %edx
leaq 0x2295(%rip), %rcx      # 0x8368
callq 0x2090
cmpq $0x0, -0x10(%rbp)
je 0x60e1
jmp 0x6100
leaq 0x175b(%rip), %rdi      # 0x7843
leaq 0x21b5(%rip), %rsi      # 0x82a4
movl $0x2c, %edx
leaq 0x226d(%rip), %rcx      # 0x8368
callq 0x2090
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6143
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6150
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x222c(%rip), %rsi      # 0x8366
movb $0x0, %al
callq 0x2140
jmp 0x610b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateFunc(Node*, _IO_FILE*)
void TranslateFunc(Node* node, FILE* file)
{
    assert(node);
    assert(file);

    fprintf(file, "%s %s(", OPERATORS[DECLARATOR].rus_name, node->value.name);
    TranslateArgs(node->right, file);
    fprintf(file, ")\n");
    TranslateCompound(node->left, file, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6169
jmp 0x6188
leaq 0xf87(%rip), %rdi       # 0x70f7
leaq 0x212d(%rip), %rsi      # 0x82a4
movl $0x3a, %edx
leaq 0x2208(%rip), %rcx      # 0x838b
callq 0x2090
cmpq $0x0, -0x10(%rbp)
je 0x6191
jmp 0x61b0
leaq 0x16ab(%rip), %rdi      # 0x7843
leaq 0x2105(%rip), %rsi      # 0x82a4
movl $0x3b, %edx
leaq 0x21e0(%rip), %rcx      # 0x838b
callq 0x2090
movq -0x10(%rbp), %rdi
movq 0x4785(%rip), %rdx      # 0xa940
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x21e4(%rip), %rsi      # 0x83ae
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6210
movq -0x10(%rbp), %rdi
leaq 0x21c8(%rip), %rsi      # 0x83b5
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x62b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateArgs(Node*, _IO_FILE*)
void TranslateArgs(Node* node, FILE* file)
{
    assert(file);

    if (node != nullptr)
    {
        fprintf(file, "%s", node->value.name);
        node = node->right;

        while (node != nullptr)
        {
            fprintf(file, ", %s", node->value.name);
            node = node->right;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6229
jmp 0x6248
leaq 0x1613(%rip), %rdi      # 0x7843
leaq 0x206d(%rip), %rsi      # 0x82a4
movl $0x45, %edx
leaq 0x2175(%rip), %rcx      # 0x83b8
callq 0x2090
cmpq $0x0, -0x8(%rbp)
je 0x62a6
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x217b(%rip), %rsi      # 0x83dd
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x62a4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x214c(%rip), %rsi      # 0x83db
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6275
jmp 0x62a6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateCompound(Node*, _IO_FILE*, unsigned long)
void TranslateCompound(Node* node, FILE* file, size_t num_tabs)
{
    assert(node);
    assert(file);

    if (node == nullptr)
    {
        return;
    }

    node = node->right;
    SetTabs(file, num_tabs);
    fprintf(file, "%s\n", OPERATORS[OPENING_BRACE].rus_name);

    while (node != nullptr)
    {
        TranslateStatement(node->left, file, num_tabs + 1);
        node = node->right;
    }

    SetTabs(file, num_tabs);
    fprintf(file, "%s\n", OPERATORS[CLOSING_BRACE].rus_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x62cd
jmp 0x62ec
leaq 0xe23(%rip), %rdi       # 0x70f7
leaq 0x1fc9(%rip), %rsi      # 0x82a4
movl $0x60, %edx
leaq 0x2118(%rip), %rcx      # 0x83ff
callq 0x2090
cmpq $0x0, -0x10(%rbp)
je 0x62f5
jmp 0x6314
leaq 0x1547(%rip), %rdi      # 0x7843
leaq 0x1fa1(%rip), %rsi      # 0x82a4
movl $0x61, %edx
leaq 0x20f0(%rip), %rcx      # 0x83ff
callq 0x2090
cmpq $0x0, -0x8(%rbp)
jne 0x6320
jmp 0x63a6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63b0
movq -0x10(%rbp), %rdi
movq 0x46dc(%rip), %rdx      # 0xaa20
leaq 0xff2(%rip), %rsi       # 0x733d
movb $0x0, %al
callq 0x2140
cmpq $0x0, -0x8(%rbp)
je 0x6380
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x6420
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6352
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63b0
movq -0x10(%rbp), %rdi
movq 0x46a8(%rip), %rdx      # 0xaa40
leaq 0xf9e(%rip), %rsi       # 0x733d
movb $0x0, %al
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateCondition(Node*, _IO_FILE*, unsigned long)
void TranslateCondition(Node* node, FILE* file, size_t num_tabs)
{
    assert(node);
    assert(file);

    fprintf(file, "%s (", OPERATORS[IF].rus_name);
    TranslateExpression(node->left, file);
    fprintf(file, ")\n");

    TranslateCompound(node->right->left, file, num_tabs);

    if (node->right->right != nullptr)
    {
        SetTabs(file, num_tabs);
        fprintf(file, "%s\n", OPERATORS[ELSE].rus_name);
        TranslateCompound(node->right->right, file, num_tabs);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x683d
jmp 0x685c
leaq 0x8b3(%rip), %rdi       # 0x70f7
leaq 0x1a59(%rip), %rsi      # 0x82a4
movl $0xdf, %edx
leaq 0x1ccf(%rip), %rcx      # 0x8526
callq 0x2090
cmpq $0x0, -0x10(%rbp)
je 0x6865
jmp 0x6884
leaq 0xfd7(%rip), %rdi       # 0x7843
leaq 0x1a31(%rip), %rsi      # 0x82a4
movl $0xe0, %edx
leaq 0x1ca7(%rip), %rcx      # 0x8526
callq 0x2090
movq -0x10(%rbp), %rdi
movq 0x4131(%rip), %rdx      # 0xa9c0
leaq 0x1c8b(%rip), %rsi      # 0x8521
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6660
movq -0x10(%rbp), %rdi
leaq 0x1afc(%rip), %rsi      # 0x83b5
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x62b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x6927
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63b0
movq -0x10(%rbp), %rdi
movq 0x40e0(%rip), %rdx      # 0xa9e0
leaq 0xa36(%rip), %rsi       # 0x733d
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x62b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateLoop(Node*, _IO_FILE*, unsigned long)
void TranslateLoop(Node* node, FILE* file, size_t num_tabs)
{
    assert(node);
    assert(file);

    fprintf(file, "%s (", OPERATORS[LOOP].rus_name);
    TranslateExpression(node->left, file);
    fprintf(file, ")\n");

    TranslateCompound(node->right, file, num_tabs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x694d
jmp 0x696c
leaq 0x7a3(%rip), %rdi       # 0x70f7
leaq 0x1949(%rip), %rsi      # 0x82a4
movl $0xd3, %edx
leaq 0x1b8f(%rip), %rcx      # 0x84f6
callq 0x2090
cmpq $0x0, -0x10(%rbp)
je 0x6975
jmp 0x6994
leaq 0xec7(%rip), %rdi       # 0x7843
leaq 0x1921(%rip), %rsi      # 0x82a4
movl $0xd4, %edx
leaq 0x1b67(%rip), %rcx      # 0x84f6
callq 0x2090
movq -0x10(%rbp), %rdi
movq 0x3fe1(%rip), %rdx      # 0xa980
leaq 0x1b7b(%rip), %rsi      # 0x8521
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6660
movq -0x10(%rbp), %rdi
leaq 0x19ec(%rip), %rsi      # 0x83b5
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x62b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateStdCall(Node*, _IO_FILE*)
bool TranslateStdCall(Node* node, FILE* file)
{
    assert(node);
    assert(file);

    if (strcmp(node->left->value.name, "scan") == 0)
    {
        fprintf(file, "nepravdoi()");
        return true;
    }

    if (strcmp(node->left->value.name, "print") == 0)
    {
        fprintf(file, "govoru(");
        TranslateParams(node->right, file);
        fprintf(file, ");\n");
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6a09
jmp 0x6a28
leaq 0x6e7(%rip), %rdi       # 0x70f7
leaq 0x188d(%rip), %rsi      # 0x82a4
movl $0xbd, %edx
leaq 0x1a8e(%rip), %rcx      # 0x84b1
callq 0x2090
cmpq $0x0, -0x18(%rbp)
je 0x6a31
jmp 0x6a50
leaq 0xe0b(%rip), %rdi       # 0x7843
leaq 0x1865(%rip), %rsi      # 0x82a4
movl $0xbe, %edx
leaq 0x1a66(%rip), %rcx      # 0x84b1
callq 0x2090
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x1a74(%rip), %rsi      # 0x84d7
callq 0x2130
cmpl $0x0, %eax
jne 0x6a85
movq -0x18(%rbp), %rdi
leaq 0x1a64(%rip), %rsi      # 0x84dc
movb $0x0, %al
callq 0x2140
movb $0x1, -0x1(%rbp)
jmp 0x6ae1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x1a50(%rip), %rsi      # 0x84e8
callq 0x2130
cmpl $0x0, %eax
jne 0x6add
movq -0x18(%rbp), %rdi
leaq 0x1a41(%rip), %rsi      # 0x84ee
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6af0
movq -0x18(%rbp), %rdi
leaq 0x19ba(%rip), %rsi      # 0x848a
movb $0x0, %al
callq 0x2140
movb $0x1, -0x1(%rbp)
jmp 0x6ae1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateParams(Node*, _IO_FILE*)
void TranslateParams(Node* node, FILE* file)
{
    assert(file);

    if (node != nullptr)
    {
        while (node->right != nullptr)
        {
            node = node->right;
        }

        TranslateExpression(node->left, file);
        node = node->parent;

        while (node->type == ARG_TYPE)
        {
            fprintf(file, ", ");
            TranslateExpression(node->left, file);
            node = node->parent;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b09
jmp 0x6b28
leaq 0xd33(%rip), %rdi       # 0x7843
leaq 0x178d(%rip), %rsi      # 0x82a4
movl $0x12e, %edx            # imm = 0x12E
leaq 0x1a77(%rip), %rcx      # 0x859a
callq 0x2090
cmpq $0x0, -0x8(%rbp)
je 0x6ba3
jmp 0x6b31
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6b4a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6b31
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6660
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x6ba1
movq -0x10(%rbp), %rdi
leaq 0x1a44(%rip), %rsi      # 0x85bf
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6660
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6b67
jmp 0x6ba3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vssense[P]Compiler/src/front-end/translator.cpp
// Function: IntToDrevniyRus(_IO_FILE*, int)
void IntToDrevniyRus(FILE* file, int number)
{
    assert(file);

    if (number == 0)
    {
        fprintf(file, "����");
        return;
    }

    bool NeededBracket = false;
    if (number < 0)
    {
        fprintf(file, "(������� - ��������) * ");
        number *= -1;
        if (number - 1 > rank)
        {
            NeededBracket = true;
        }
    }

    if (NeededBracket)
    {
        fprintf(file, "(");
    }

    for (size_t power = 0; number > 0; ++power)
    {
        int digit = number % rank;
        fprintf(file, "%s", DIGITS[digit].rus_digit);

        for (size_t i = 0; i < power; ++i)
        {
            fprintf(file, " * ���������");
        }

        if (number > rank)
        {
            fprintf(file, " + ");
        }

        number /= rank;
    }

    if (NeededBracket)
    {
        fprintf(file, ")");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6c38
jmp 0x6c57
leaq 0xc04(%rip), %rdi       # 0x7843
leaq 0x165e(%rip), %rsi      # 0x82a4
movl $0x145, %edx            # imm = 0x145
leaq 0x1970(%rip), %rcx      # 0x85c2
callq 0x2090
cmpl $0x0, -0xc(%rbp)
jne 0x6c74
movq -0x8(%rbp), %rdi
leaq 0x918(%rip), %rsi       # 0x7580
movb $0x0, %al
callq 0x2140
jmp 0x6d88
movb $0x0, -0xd(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6ca8
movq -0x8(%rbp), %rdi
leaq 0x195b(%rip), %rsi      # 0x85e4
movb $0x0, %al
callq 0x2140
imull $-0x1, -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cmpl $0xa, %eax
jle 0x6ca6
movb $0x1, -0xd(%rbp)
jmp 0x6ca8
testb $0x1, -0xd(%rbp)
je 0x6cc0
movq -0x8(%rbp), %rdi
leaq 0x186b(%rip), %rsi      # 0x8524
movb $0x0, %al
callq 0x2140
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x6d70
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x3f71(%rip), %rax      # 0xac60
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x16dd(%rip), %rsi      # 0x83dd
movb $0x0, %al
callq 0x2140
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6d39
movq -0x8(%rbp), %rdi
leaq 0x18d8(%rip), %rsi      # 0x85fc
movb $0x0, %al
callq 0x2140
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6d0f
cmpl $0xa, -0xc(%rbp)
jle 0x6d51
movq -0x8(%rbp), %rdi
leaq 0x18bf(%rip), %rsi      # 0x8609
movb $0x0, %al
callq 0x2140
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6cc8
testb $0x1, -0xd(%rbp)
je 0x6d88
movq -0x8(%rbp), %rdi
leaq 0xfeb(%rip), %rsi       # 0x7d6c
movb $0x0, %al
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
// File: chuckwolber[P]Cube/order/cli.cpp
// Function: setFindAllOrders()
void setFindAllOrders() {
    skipFoundOrders = true;
    numSkipFoundOrders = 0;
    findOrders = "";

    for (int i = 0; i < ORDER_MAX; i++)
        foundOrders.push_back(true);
    for (int order : allOrders) {
        foundOrders[(size_t)order] = false;
        findOrders += std::to_string(order) +  ",";
    }
    findOrders.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb $0x1, 0x1e92f(%rip)     # 0x2b721
movq $0x0, 0x1e90b(%rip) # 0x2b708
leaq 0x1e8ac(%rip), %rdi     # 0x2b6b0
leaq 0xfcae(%rip), %rsi      # 0x1cab9
callq 0x44e0
movl $0x0, -0x4(%rbp)
cmpl $0x4ed, -0x4(%rbp)      # imm = 0x4ED
jge 0xce3c
leaq 0x1e8a9(%rip), %rdi     # 0x2b6d0
movl $0x1, %esi
callq 0xf040
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xce17
leaq 0x1e51d(%rip), %rax     # 0x2b360
movq %rax, -0x10(%rbp)
leaq 0x1e512(%rip), %rax     # 0x2b360
movq %rax, -0x18(%rbp)
leaq 0x1e507(%rip), %rax     # 0x2b360
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xcf32
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rsi
leaq 0x1e84b(%rip), %rdi     # 0x2b6d0
callq 0xf110
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xf170
movl -0x24(%rbp), %esi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xf210
movq -0x90(%rbp), %rsi
leaq 0xf8e7(%rip), %rdx      # 0x1c7a5
leaq -0x58(%rbp), %rdi
callq 0xf1c0
jmp 0xcec9
leaq 0x1e7e0(%rip), %rdi     # 0x2b6b0
leaq -0x58(%rbp), %rsi
callq 0x4490
jmp 0xcedb
leaq -0x58(%rbp), %rdi
callq 0x4678
leaq -0x78(%rbp), %rdi
callq 0x4678
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0xce63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xcf27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4678
leaq -0x78(%rbp), %rdi
callq 0x4678
jmp 0xcf47
leaq 0x1e777(%rip), %rdi     # 0x2b6b0
callq 0x4450
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x45e0
// File: chuckwolber[P]Cube/order/./AlgorithmTally.hpp
// Function: Algorithms::combine(AlgorithmTally const*, AlgorithmTally const*) const
virtual AlgorithmTally* combine(const AlgorithmTally* left, const AlgorithmTally* right) const {
            AlgorithmTally* at = init();
            at->algorithms->insert(at->algorithms->end(), left->algorithms->begin(), left->algorithms->end());
            at->algorithms->insert(at->algorithms->end(), right->algorithms->begin(), right->algorithms->end());
            return at;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7330
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x72f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7280
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7330
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x11730
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7330
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x72f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7280
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7330
movq -0x78(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x11730
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/order/./AlgorithmTally.hpp
// Function: Algorithms::accum(AlgorithmTally*, unsigned long long) const
virtual void accum(AlgorithmTally* accumulator, unsigned long long int index) const {
            unsigned long long int x = accumulator->algorithm->getAlgorithmNumber();
            *(accumulator->algorithm) += (index - x);
            if (!(*(accumulator->algorithm).*re)())
                accumulator->algorithms->push_back(index);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5280
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rax, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5010
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq 0x28(%rdx), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rdx), %rdx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x10b74
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x40(%rbp)
jmp 0x10b7c
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
callq *%rax
testb $0x1, %al
jne 0x10b9b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12560
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: chuckwolber[P]Cube/order/./SchwartzGeneratorReduce.hpp
// Function: SchwartzGeneratorReduce<AlgorithmTally, std::vector<unsigned long long, std::allocator<unsigned long long>>>::~SchwartzGeneratorReduce()
virtual ~SchwartzGeneratorReduce() {
            if (interior != NULL) {
                for (TallyType* t : *interior)
                    delete t;
                delete interior;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x19d8d(%rip), %rcx     # 0x2aa08
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x10d33
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11440
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11470
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x114a0
testb $0x1, %al
jne 0x10cc6
jmp 0x10d08
leaq -0x18(%rbp), %rdi
callq 0x114e0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x10cfb
movq -0x38(%rbp), %rdi
callq 0x11500
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x4390
jmp 0x10cfd
leaq -0x18(%rbp), %rdi
callq 0x11570
jmp 0x10cb3
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x10d31
movq -0x40(%rbp), %rdi
callq 0x11590
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0x4390
jmp 0x10d33
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: chuckwolber[P]Cube/order/./SchwartzGeneratorReduce.hpp
// Function: SchwartzGeneratorReduce<AlgorithmTally, std::vector<unsigned long long, std::allocator<unsigned long long>>>::getSize()
unsigned long long int getSize() {
            unsigned long long int size = dataSize / n_threads;
            if (size*n_threads != size)
                ++size;
            return size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rax
xorl %edx, %edx
divq 0x18(%rcx)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
imulq 0x18(%rcx), %rax
cmpq -0x10(%rbp), %rax
je 0x1bb25
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: tismith[P]tmp-play/church.cpp
// Function: main
int main() {
    std::cout << "AND(TRUE,TRUE) == ";
    std::cout << (typeid(AND::F<TRUE,TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

    std::cout << "AND(FALSE,TRUE) == ";
    std::cout << (typeid(AND::F<FALSE,TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

    std::cout << "OR(FALSE,TRUE) == ";
    std::cout << (typeid(OR::F<FALSE,TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

#if 0
    std::cout << "NOT(TRUE) == ";
    std::cout << (typeid(NOT::F<TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

    std::cout << "NOT(FALSE) == ";
    std::cout << (typeid(NOT::F<FALSE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2dfd(%rip), %rdi      # 0x3fd8
leaq 0xe22(%rip), %rsi       # 0x2004
callq 0x1040
leaq 0x2ba2(%rip), %rsi      # 0x3d90
movq %rsi, %rdi
callq 0x12c0
movzbl %al, %esi
andl $0x1, %esi
movq 0x2dd5(%rip), %rdi      # 0x3fd8
callq 0x1080
movq 0x2dc9(%rip), %rdi      # 0x3fd8
movq 0x2db2(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2db6(%rip), %rdi      # 0x3fd8
leaq 0xdee(%rip), %rsi       # 0x2017
callq 0x1040
leaq 0x2b6b(%rip), %rdi      # 0x3da0
leaq 0x2b54(%rip), %rsi      # 0x3d90
callq 0x12c0
movzbl %al, %esi
andl $0x1, %esi
movq 0x2d8a(%rip), %rdi      # 0x3fd8
callq 0x1080
movq 0x2d7e(%rip), %rdi      # 0x3fd8
movq 0x2d67(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0x2d6b(%rip), %rdi      # 0x3fd8
leaq 0xdb7(%rip), %rsi       # 0x202b
callq 0x1040
leaq 0x2b10(%rip), %rsi      # 0x3d90
movq %rsi, %rdi
callq 0x12c0
movzbl %al, %esi
andl $0x1, %esi
movq 0x2d43(%rip), %rdi      # 0x3fd8
callq 0x1080
movq 0x2d37(%rip), %rdi      # 0x3fd8
movq 0x2d20(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CRangeDecoder::Init()
bool CRangeDecoder::Init()
{
  Corrupted = false;
  Range = 0xFFFFFFFF;
  Code = 0;
  Perplexity = 0.f;

  Byte b = InStream->ReadByte();

  for (int i = 0; i < 4; i++)
    Code = (Code << 8) | InStream->ReadByte();

  if (b != 0 || Code == Range)
    Corrupted = true;
  return b == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0x10(%rax)
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x4(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
movq 0x8(%rax), %rdi
callq 0x3cb0
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x2498
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shll $0x8, %ecx
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rdi
callq 0x3cb0
movl -0x1c(%rbp), %ecx
movb %al, %dl
movq -0x18(%rbp), %rax
movzbl %dl, %edx
orl %edx, %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2460
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x24ac
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x24b4
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rax)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CRangeDecoder::DecodeDirectBits(unsigned int)
UInt32 CRangeDecoder::DecodeDirectBits(unsigned numBits)
{
  Perplexity += numBits;
  UInt32 res = 0;
  do
  {
    Range >>= 1;
    Code -= Range;
    UInt32 t = 0 - ((UInt32)Code >> 31);
    Code += Range & t;

    if (Code == Range)
      Corrupted = true;

    Normalize();
    res <<= 1;
    res += t + 1;
  }
  while (--numBits);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
cvtsi2ss %rcx, %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rax)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl (%rcx), %eax
shrl %eax
movl %eax, (%rcx)
movl (%rcx), %edx
movl 0x4(%rcx), %eax
subl %edx, %eax
movl %eax, 0x4(%rcx)
movl 0x4(%rcx), %edx
shrl $0x1f, %edx
xorl %eax, %eax
subl %edx, %eax
movl %eax, -0x14(%rbp)
movl (%rcx), %eax
andl -0x14(%rbp), %eax
addl 0x4(%rcx), %eax
movl %eax, 0x4(%rcx)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x258b
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x24d0
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x2550
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CRangeDecoder::DecodeBit(unsigned short*)
unsigned CRangeDecoder::DecodeBit(CProb *prob)
{
  unsigned v = *prob;
  UInt32 bound = (Range >> kNumBitModelTotalBits) * v;
  unsigned symbol;
  if (Code < bound)
  {
    Perplexity += -log2(v/2048.f);
    v += ((1 << kNumBitModelTotalBits) - v) >> kNumMoveBits;
    Range = bound;
    symbol = 0;
  }
  else
  {
    Perplexity += -log2(1.f-v/2048.f);
    v -= v >> kNumMoveBits;
    Code -= bound;
    Range -= bound;
    symbol = 1;
  }
  *prob = (CProb)v;
  Normalize();
  return symbol;
}

// 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), %rcx
movzwl (%rcx), %ecx
movl %ecx, -0x14(%rbp)
movl (%rax), %ecx
shrl $0xb, %ecx
imull -0x14(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jae 0x264a
movl -0x14(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss 0x8a02(%rip), %xmm1     # 0xb008
divss %xmm1, %xmm0
callq 0x3d20
movq -0x28(%rbp), %rax
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rax)
movl $0x800, %ecx            # imm = 0x800
subl -0x14(%rbp), %ecx
shrl $0x5, %ecx
addl -0x14(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x1c(%rbp)
jmp 0x26b4
movl -0x14(%rbp), %eax
cvtsi2ss %rax, %xmm1
movss 0x89ae(%rip), %xmm0     # 0xb008
divss %xmm0, %xmm1
movss 0x899e(%rip), %xmm0     # 0xb004
subss %xmm1, %xmm0
callq 0x3d20
movq -0x28(%rbp), %rax
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rax)
movl -0x14(%rbp), %edx
shrl $0x5, %edx
movl -0x14(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0x14(%rbp)
movl -0x18(%rbp), %edx
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %edx
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl $0x1, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
callq 0x24d0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: BitTreeReverseDecode(unsigned short*, unsigned int, CRangeDecoder*)
unsigned BitTreeReverseDecode(CProb *probs, unsigned numBits, CRangeDecoder *rc)
{
  unsigned m = 1;
  unsigned symbol = 0;
  for (unsigned i = 0; i < numBits; i++)
  {
    unsigned bit = rc->DecodeBit(&probs[m]);
    m <<= 1;
    m += bit;
    symbol |= (bit << i);
  }
  return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2753
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %eax
shlq %rax
addq %rax, %rsi
callq 0x25c0
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
shll %cl, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2708
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: output_raw(CLzmaDecoder&, double)
static int output_raw(CLzmaDecoder& lzmaDecoder, double maxPerplexity) {
  for (int j = 0; j < lzmaDecoder.OutWindow.OutStream.Data.size(); j++) {
    std::cout << lzmaDecoder.Perplexities[j]/maxPerplexity << std::endl;
  }
  std::cout << std::endl;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq $0x18, %rdi
callq 0x5970
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c21
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6310
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
divsd -0x10(%rbp), %xmm0
movq 0xc3ce(%rip), %rdi      # 0xffd0
callq 0x2290
movq %rax, %rdi
movq 0xc3a7(%rip), %rsi      # 0xffb8
callq 0x2190
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3bb8
movq 0xc3a8(%rip), %rdi      # 0xffd0
movq 0xc389(%rip), %rsi      # 0xffb8
callq 0x2190
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CInputStream::ReadByte()
Byte ReadByte()
  {
    int c = getc(File);
    if (c < 0)
      throw "Unexpected end of file";
    Processed++;
    return (Byte)c;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x2050
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3cfc
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
leaq 0x73d6(%rip), %rax      # 0xb0bf
movq %rax, (%rdi)
movq 0xc2cd(%rip), %rsi      # 0xffc0
xorl %eax, %eax
movl %eax, %edx
callq 0x2240
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::Init()
void Init()
  {
    InitLiterals();
    InitDist();

    INIT_PROBS(IsMatch);
    INIT_PROBS(IsRep);
    INIT_PROBS(IsRepG0);
    INIT_PROBS(IsRepG1);
    INIT_PROBS(IsRepG2);
    INIT_PROBS(IsRep0Long);

    LenDecoder.Init();
    RepLenDecoder.Init();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4920
movq -0x28(%rbp), %rdi
callq 0x4980
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0xc0, %rax
jae 0x3d90
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movw $0x400, 0x3ae(%rax,%rcx,2) # imm = 0x400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d69
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0xc, %rax
jae 0x3dbc
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
movw $0x400, 0x52e(%rax,%rcx,2) # imm = 0x400
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3d97
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0xc, %rax
jae 0x3de8
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movw $0x400, 0x546(%rax,%rcx,2) # imm = 0x400
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3dc3
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpq $0xc, %rax
jae 0x3e14
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movw $0x400, 0x55e(%rax,%rcx,2) # imm = 0x400
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3def
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0xc, %rax
jae 0x3e40
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movw $0x400, 0x576(%rax,%rcx,2) # imm = 0x400
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e1b
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpq $0xc0, %rax
jae 0x3e6e
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movw $0x400, 0x58e(%rax,%rcx,2) # imm = 0x400
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e47
movq -0x28(%rbp), %rdi
addq $0x70e, %rdi            # imm = 0x70E
callq 0x4a10
movq -0x28(%rbp), %rdi
addq $0xb12, %rdi            # imm = 0xB12
callq 0x4a10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::DecodeLiteral(unsigned int, unsigned int)
void DecodeLiteral(unsigned state, UInt32 rep0)
  {
    unsigned prevByte = 0;
    if (!OutWindow.IsEmpty())
      prevByte = OutWindow.GetByte(1);

    unsigned symbol = 1;
    unsigned litState = ((OutWindow.TotalPos & ((1 << lp) - 1)) << lc) + (prevByte >> (8 - lc));
    CProb *probs = &LitProbs[(UInt32)0x300 * litState];

    if (state >= 7)
    {
      unsigned matchByte = OutWindow.GetByte(rep0 + 1);
      do
      {
        unsigned matchBit = (matchByte >> 7) & 1;
        matchByte <<= 1;
        unsigned bit = RangeDec.DecodeBit(&probs[((1 + matchBit) << 8) + symbol]);
        symbol = (symbol << 1) | bit;
        if (matchBit != bit)
          break;
      }
      while (symbol < 0x100);
    }
    while (symbol < 0x100)
      symbol = (symbol << 1) | RangeDec.DecodeBit(&probs[symbol]);
    OutWindow.PutByte((Byte)(symbol - 0x100));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
addq $0x18, %rdi
callq 0x4180
testb $0x1, %al
jne 0x3f06
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x4220
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x40(%rbp), %rax
movl $0x1, -0x18(%rbp)
movl 0x2c(%rax), %edx
movl 0x94(%rax), %ecx
movl $0x1, %esi
shll %cl, %esi
movl %esi, %ecx
subl $0x1, %ecx
andl %ecx, %edx
movl 0x8c(%rax), %ecx
shll %cl, %edx
movl %edx, -0x44(%rbp)
movl -0x14(%rbp), %edx
movl $0x8, %ecx
subl 0x8c(%rax), %ecx
shrl %cl, %edx
movl -0x44(%rbp), %ecx
addl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq 0xa0(%rax), %rax
imull $0x300, -0x1c(%rbp), %ecx # imm = 0x300
movl %ecx, %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpl $0x7, -0xc(%rbp)
jb 0x3fde
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movl -0x10(%rbp), %esi
addl $0x1, %esi
callq 0x4220
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %eax
shrl $0x7, %eax
andl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
shll %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %eax
addl $0x1, %eax
shll $0x8, %eax
addl -0x18(%rbp), %eax
movl %eax, %eax
shlq %rax
addq %rax, %rsi
callq 0x25c0
movl %eax, -0x34(%rbp)
movl -0x18(%rbp), %eax
shll %eax
orl -0x34(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x3fd1
jmp 0x3fdc
jmp 0x3fd3
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jb 0x3f84
jmp 0x3fde
jmp 0x3fe0
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jae 0x4013
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x48(%rbp)
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %eax
shlq %rax
addq %rax, %rsi
callq 0x25c0
movl %eax, %ecx
movl -0x48(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x3fe0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movl -0x18(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
movzbl %al, %esi
callq 0x41b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: COutWindow::PutByte(unsigned char)
void PutByte(Byte b)
  {
    TotalPos++;
    Buf[Pos++] = b;
    if (Pos == Size)
    {
      Pos = 0;
      IsFull = true;
    }
    OutStream.WriteByte(b);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x14(%rcx)
movb -0x9(%rbp), %sil
movq (%rcx), %rax
movl 0x8(%rcx), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rcx)
movl %edx, %edx
movb %sil, (%rax,%rdx)
movl 0x8(%rcx), %eax
cmpl 0xc(%rcx), %eax
jne 0x4202
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movzbl -0x9(%rbp), %esi
callq 0x5470
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLenDecoder::Decode(CRangeDecoder*, unsigned int)
unsigned Decode(CRangeDecoder *rc, unsigned posState)
  {
    if (rc->DecodeBit(&Choice) == 0)
      return LowCoder[posState].Decode(rc);
    if (rc->DecodeBit(&Choice2) == 0)
      return 8 + MidCoder[posState].Decode(rc);
    return 16 + HighCoder.Decode(rc);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25c0
cmpl $0x0, %eax
jne 0x42b9
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
movl -0x1c(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x5c60
movl %eax, -0x4(%rbp)
jmp 0x430f
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x2, %rsi
callq 0x25c0
cmpl $0x0, %eax
jne 0x42f5
movq -0x28(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movl -0x1c(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x5c60
addl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x430f
movq -0x28(%rbp), %rdi
addq $0x204, %rdi            # imm = 0x204
movq -0x18(%rbp), %rsi
callq 0x5cd0
addl $0x10, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::DecodeDistance(unsigned int)
unsigned DecodeDistance(unsigned len)
  {
    unsigned lenState = len;
    if (lenState > kNumLenToPosStates - 1)
      lenState = kNumLenToPosStates - 1;

    unsigned posSlot = PosSlotDecoder[lenState].Decode(&RangeDec);
    if (posSlot < 4)
      return posSlot;

    unsigned numDirectBits = (unsigned)((posSlot >> 1) - 1);
    UInt32 dist = ((2 | (posSlot & 1)) << numDirectBits);
    if (posSlot < kEndPosModelIndex)
      dist += BitTreeReverseDecode(PosDecoders + dist - posSlot, numDirectBits, &RangeDec);
    else
    {
      dist += RangeDec.DecodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;
      dist += AlignDecoder.ReverseDecode(&RangeDec);
    }
    return dist;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jbe 0x434a
movl $0x3, -0x18(%rbp)
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0xa8, %rdi
movl -0x18(%rbp), %eax
shlq $0x7, %rax
addq %rax, %rdi
callq 0x5d40
movl %eax, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jae 0x437b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x440b
movl -0x1c(%rbp), %eax
shrl %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
orl $0x2, %eax
movl -0x20(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x24(%rbp)
cmpl $0xe, -0x1c(%rbp)
jae 0x43d4
movq -0x30(%rbp), %rdx
movq %rdx, %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movl -0x24(%rbp), %eax
shlq %rax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
shlq %rax
addq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x26e0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x4405
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
subl $0x4, %esi
callq 0x2520
movq -0x30(%rbp), %rsi
shll $0x4, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq %rsi, %rdi
addq $0x2a8, %rdi            # imm = 0x2A8
callq 0x5db0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::DecodeProperties(unsigned char const*)
void DecodeProperties(const Byte *properties)
  {
    unsigned d = properties[0];
    if (d >= (9 * 5 * 5))
      throw "Incorrect LZMA properties";
    lc = d % 9;
    d /= 9;
    pb = d / 5;
    lp = d % 5;
    dictSizeInProperties = 0;
    for (int i = 0; i < 4; i++)
      dictSizeInProperties |= (UInt32)properties[i + 1] << (8 * i);
    dictSize = dictSizeInProperties;
    if (dictSize < LZMA_DIC_MIN)
      dictSize = LZMA_DIC_MIN;
  }

// 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)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xe1, -0x14(%rbp)
jb 0x46e2
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
leaq 0x6b18(%rip), %rax      # 0xb1e7
movq %rax, (%rdi)
movq 0xb8e7(%rip), %rsi      # 0xffc0
xorl %eax, %eax
movl %eax, %edx
callq 0x2240
movl -0x14(%rbp), %eax
movl $0x9, %ecx
xorl %edx, %edx
divl %ecx
movq -0x20(%rbp), %rax
movl %edx, 0x8c(%rax)
movl -0x14(%rbp), %eax
movl $0x9, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x90(%rax)
movl -0x14(%rbp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movq -0x20(%rbp), %rax
movl %edx, 0x94(%rax)
movl $0x0, 0x9c(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x4782
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %edx
movl -0x18(%rbp), %ecx
shll $0x3, %ecx
shll %cl, %edx
movl %edx, %ecx
orl 0x9c(%rax), %ecx
movl %ecx, 0x9c(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4746
movq -0x20(%rbp), %rax
movl 0x9c(%rax), %ecx
movl %ecx, 0x98(%rax)
cmpl $0x1000, 0x98(%rax)     # imm = 0x1000
jae 0x47ac
movq -0x20(%rbp), %rax
movl $0x1000, 0x98(%rax)     # imm = 0x1000
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::InitDist()
void InitDist()
  {
    for (unsigned i = 0; i < kNumLenToPosStates; i++)
      PosSlotDecoder[i].Init();
    AlignDecoder.Init();
    INIT_PROBS(PosDecoders);
  }

// 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)
cmpl $0x4, -0xc(%rbp)
jae 0x49c6
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
movl -0xc(%rbp), %eax
shlq $0x7, %rax
addq %rax, %rdi
callq 0x4a90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x499b
movq -0x18(%rbp), %rdi
addq $0x2a8, %rdi            # imm = 0x2A8
callq 0x4ad0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0x73, %rax
jae 0x4a02
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movw $0x400, 0x2c8(%rax,%rcx,2) # imm = 0x400
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x49dd
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLenDecoder::Init()
void Init()
  {
    Choice = PROB_INIT_VAL;
    Choice2 = PROB_INIT_VAL;
    HighCoder.Init();
    for (unsigned i = 0; i < (1 << kNumPosBitsMax); i++)
    {
      LowCoder[i].Init();
      MidCoder[i].Init();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movw $0x400, (%rdi)          # imm = 0x400
movw $0x400, 0x2(%rdi)       # imm = 0x400
addq $0x204, %rdi            # imm = 0x204
callq 0x4b10
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jae 0x4a84
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x4b50
movq -0x18(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x4b50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4a42
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)