LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetTerm(Parser*, unsigned long*)
Node* GetTerm(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* result = GetPrimaryExpression(parser, ofs);

    while (TYPE == TYPE_OP && (VALUE.op == MUL || VALUE.op == DIV))
    {
        Value op = VALUE;
        (*ofs)++;

        result = ConstructNode(MATH_TYPE, op, result, GetPrimaryExpression(parser, ofs));
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x91b9
jmp 0x91d8
leaq 0x23af(%rip), %rdi      # 0xb56f
leaq 0x2df0(%rip), %rsi      # 0xbfb7
movl $0x173, %edx            # imm = 0x173
leaq 0x3028(%rip), %rcx      # 0xc1fb
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x29(%rbp)
jne 0x9244
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0xc, 0x8(%rcx)
movb %al, -0x2a(%rbp)
je 0x923e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0xd, 0x8(%rax)
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x924d
jmp 0x92b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x92c0
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rsi
movl $0xe, %edi
callq 0x7980
movq %rax, -0x18(%rbp)
jmp 0x91e9
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetParams(Parser*, unsigned long*)
Node* GetParams(Parser* parser, size_t* ofs)
{
    assert(parser);

    CheckOpeningRoundBracket(parser, ofs);

    Node* result = nullptr;

    if (TYPE != TYPE_OP || VALUE.op != CLOSING_ROUND_BRACKET)
    {
        result = ConstructNode(ARG_TYPE, GetExpression(parser, ofs), nullptr);

        while (TYPE == TYPE_OP && VALUE.op == COMMA)
        {
            (*ofs)++;

            result->parent = ConstructNode(ARG_TYPE, GetExpression(parser, ofs), nullptr);
            result->parent->right = result;
            result = result->parent;
        }
    }

    CheckClosingRoundBracket(parser, ofs);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9529
jmp 0x9548
leaq 0x203f(%rip), %rdi      # 0xb56f
leaq 0x2a80(%rip), %rsi      # 0xbfb7
movl $0x1c3, %edx            # imm = 0x1C3
leaq 0x2d55(%rip), %rcx      # 0xc298
callq 0x20a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81d0
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x9590
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x14, 0x8(%rax)
je 0x964d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, %rsi
movl $0x5, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7af0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x18, (%rax), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0x19(%rbp)
jne 0x95ea
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
cmpl $0x18, 0x8(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x95f3
jmp 0x964b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, %rsi
movl $0x5, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7af0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x95b2
jmp 0x964d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8270
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vssense[P]Compiler/src/front-end/tree.cpp
// Function: GetMemoryAccess(Parser*, unsigned long*)
Node* GetMemoryAccess(Parser* parser, size_t* ofs)
{
    assert(parser);

    Node* id = ID(nullptr, nullptr);
    CheckOpeningSquareBracket(parser, ofs);
    Node* expression = GetExpression(parser, ofs);
    CheckClosingSquareBracket(parser, ofs);

    return ConstructNode(MEM_ACCESS_TYPE, id, expression);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9689
jmp 0x96a8
leaq 0x1edf(%rip), %rdi      # 0xb56f
leaq 0x2920(%rip), %rsi      # 0xbfb7
movl $0x1a8, %edx            # imm = 0x1A8
leaq 0x2ba9(%rip), %rcx      # 0xc24c
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7980
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8c80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8bb0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d20
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x3, %edi
callq 0x7af0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/front-end/iotree.cpp
// Function: WriteToFile(Tree*, char const*)
void WriteToFile(Tree* tree, const char* output)
{
    assert(tree);
    assert(output);

    FILE* file = fopen(output, "w");
    assert(file);

    WriteToFileRecursively(tree->root, file);

    fclose(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9749
jmp 0x9768
leaq 0x1553(%rip), %rdi      # 0xaca3
leaq 0x2d69(%rip), %rsi      # 0xc4c0
movl $0x9, %edx
leaq 0x2d76(%rip), %rcx      # 0xc4d9
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x9771
jmp 0x9790
leaq 0x2d88(%rip), %rdi      # 0xc500
leaq 0x2d41(%rip), %rsi      # 0xc4c0
movl $0xa, %edx
leaq 0x2d4e(%rip), %rcx      # 0xc4d9
callq 0x20a0
movq -0x10(%rbp), %rdi
leaq 0x118f(%rip), %rsi      # 0xa92a
callq 0x2120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x97ad
jmp 0x97cc
leaq 0x128f(%rip), %rdi      # 0xaa43
leaq 0x2d05(%rip), %rsi      # 0xc4c0
movl $0xd, %edx
leaq 0x2d12(%rip), %rcx      # 0xc4d9
callq 0x20a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x97f0
movq -0x18(%rbp), %rdi
callq 0x2100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/front-end/iotree.cpp
// Function: WriteToFileRecursively(Node*, _IO_FILE*)
void WriteToFileRecursively(Node* node, FILE* file)
{
    assert(file);

    if (node == nullptr)
    {
        return;
    }

    fprintf(file, "%d | ", node->type);

    if (node->type == NUMB_TYPE)
    {
        fprintf(file, "%d ", node->value.number);
    }
    else if (node->type == ID_TYPE)
    {
        fprintf(file, "%s ", node->value.name);
    }
    else
    {
        fprintf(file, "%d ", node->value.op);
    }


    fprintf(file, "{ ");
    WriteToFileRecursively(node->left, file);
    fprintf(file, "} ");

    fprintf(file, "{ ");
    WriteToFileRecursively(node->right, file);
    fprintf(file, "} ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9809
jmp 0x9828
leaq 0x1233(%rip), %rdi      # 0xaa43
leaq 0x2ca9(%rip), %rsi      # 0xc4c0
movl $0x16, %edx
leaq 0x2ce4(%rip), %rcx      # 0xc507
callq 0x20a0
cmpq $0x0, -0x8(%rbp)
jne 0x9834
jmp 0x991a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x2cee(%rip), %rsi      # 0xc533
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
cmpl $0xf, (%rax)
jne 0x9870
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x2cd2(%rip), %rsi      # 0xc539
movb $0x0, %al
callq 0x2160
jmp 0x98b0
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x9895
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x2cb1(%rip), %rsi      # 0xc53d
movb $0x0, %al
callq 0x2160
jmp 0x98ae
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x2c92(%rip), %rsi      # 0xc539
movb $0x0, %al
callq 0x2160
jmp 0x98b0
movq -0x10(%rbp), %rdi
leaq 0x2c86(%rip), %rsi      # 0xc541
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x97f0
movq -0x10(%rbp), %rdi
leaq 0x2c66(%rip), %rsi      # 0xc544
movb $0x0, %al
callq 0x2160
movq -0x10(%rbp), %rdi
leaq 0x2c51(%rip), %rsi      # 0xc541
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x97f0
movq -0x10(%rbp), %rdi
leaq 0x2c31(%rip), %rsi      # 0xc544
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
// File: vssense[P]Compiler/src/front-end/iotree.cpp
// Function: GetTreeFromFile(char const*)
Tree* GetTreeFromFile(const char* file)
{
    assert(file);

    Buffer* buffer = GetBuffer(file);

    Tree* tree = NewTree();

    tree->root = ConstructNode(D_TYPE, { .op = 0 });
    buffer->str += 5;

    GetTreeFromBuffer(tree->root, buffer);

    DeleteFictiveNodes(tree->root);

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9935
jmp 0x9954
leaq 0x1107(%rip), %rdi      # 0xaa43
leaq 0x2b7d(%rip), %rsi      # 0xc4c0
movl $0x38, %edx
leaq 0x2bf8(%rip), %rcx      # 0xc547
callq 0x20a0
movq -0x8(%rbp), %rdi
callq 0x62d0
movq %rax, -0x10(%rbp)
callq 0x78b0
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x7b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x99c0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x9c30
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vssense[P]Compiler/src/front-end/iotree.cpp
// Function: DeleteFictiveNodes(Node*)
void DeleteFictiveNodes(Node* node)
{
    assert(node);

    if (node->left == nullptr && node->right == nullptr)
    {
        if (node->parent->left == node)
        {
            node->parent->left = nullptr;
        }
        else
        {
            node->parent->right = nullptr;
        }

        free(node);
    }
    else
    {
        if (node->left != nullptr)
        {
            DeleteFictiveNodes(node->left);
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9c45
jmp 0x9c64
leaq 0x2392(%rip), %rdi      # 0xbfde
leaq 0x286d(%rip), %rsi      # 0xc4c0
movl $0x85, %edx
leaq 0x295c(%rip), %rcx      # 0xc5bb
callq 0x20a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x9cb9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x9cb9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x9c9e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x18(%rax)
jmp 0x9cae
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x2130
jmp 0x9ceb
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9cd1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x9c30
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9ce9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9c30
jmp 0x9ceb
addq $0x10, %rsp
popq %rbp
retq
// File: jmbjorndalen[P]Malbolge-gen/interp-orig.c
// Function: op
static inline
#endif
unsigned short op( unsigned short x, unsigned short y )
{
  unsigned short i = 0, j;
  static const unsigned short p9[5] =
    { 1, 9, 81, 729, 6561 };
  static const unsigned short o[9][9] =
    {
      { 4, 3, 3, 1, 0, 0, 1, 0, 0 },
      { 4, 3, 5, 1, 0, 2, 1, 0, 2 },
      { 5, 5, 4, 2, 2, 1, 2, 2, 1 },
      { 4, 3, 3, 1, 0, 0, 7, 6, 6 },
      { 4, 3, 5, 1, 0, 2, 7, 6, 8 },
      { 5, 5, 4, 2, 2, 1, 8, 8, 7 },
      { 7, 6, 6, 7, 6, 6, 4, 3, 3 },
      { 7, 6, 8, 7, 6, 8, 4, 3, 5 },
      { 8, 8, 7, 8, 8, 7, 5, 5, 4 },
    };
  for ( j = 0; j < 5; j++ )
    i += o[y / p9[j] % 9][x / p9[j] % 9] * p9[j];
  return ( i );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
movw $0x0, -0x8(%rbp)
movzwl -0x8(%rbp), %eax
cmpl $0x5, %eax
jge 0x401a1a
movzwl -0x4(%rbp), %eax
movzwl -0x8(%rbp), %ecx
movl %ecx, %edx
leaq 0x96734(%rip), %rcx     # 0x4980d0
movzwl (%rcx,%rdx,2), %ecx
cltd
idivl %ecx
movl $0x9, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x9672b(%rip), %rax     # 0x4980e0
imulq $0x12, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movzwl -0x8(%rbp), %ecx
movl %ecx, %edx
leaq 0x966ff(%rip), %rcx     # 0x4980d0
movzwl (%rcx,%rdx,2), %ecx
cltd
idivl %ecx
movl $0x9, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movslq %edx, %rcx
movzwl (%rax,%rcx,2), %ecx
movzwl -0x8(%rbp), %eax
movl %eax, %edx
leaq 0x966d8(%rip), %rax     # 0x4980d0
movzwl (%rax,%rdx,2), %eax
imull %eax, %ecx
movzwl -0x6(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x6(%rbp)
movw -0x8(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x8(%rbp)
jmp 0x40197e
movw -0x6(%rbp), %ax
popq %rbp
retq
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::copy() const
Obj* Obj::copy() const {
	Obj* res = new Obj(*this);
	for(int i=0; i<objs.size(); ++i) res->objs[i] = res->objs[i]->copy();
	for(int i=0; i<motions.size(); ++i) res->motions[i] = res->motions[i]->copy();
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x78, %edi
callq 0x4270
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xa000
jmp 0x4933
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x48, %rdi
callq 0xa0c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x49c0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movslq -0x20(%rbp), %rsi
callq 0xa0e0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movslq -0x20(%rbp), %rsi
callq 0xa0e0
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4942
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x78, %esi
callq 0x4280
jmp 0x4a33
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x60, %rdi
callq 0xa100
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x4a29
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa120
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa120
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x49c7
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::erase_obj(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Obj::erase_obj(const string& key) {
	for(auto it = objs.begin(); it != objs.end(); ++it)
		if((*it)->name == key) {
			(*it)->~Obj(); objs.erase(it); return;
		}
	throw out_of_range("Obj \""+key+"\" not found in Obj \""+name+"\"!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x48, %rdi
callq 0x9e70
movq %rax, -0x18(%rbp)
movq -0xc8(%rbp), %rdi
addq $0x48, %rdi
callq 0x9d40
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9ea0
testb $0x1, %al
jne 0x4bd2
jmp 0x4c4e
leaq -0x18(%rbp), %rdi
callq 0x9ee0
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xa230
testb $0x1, %al
jne 0x4bf1
jmp 0x4c3e
leaq -0x18(%rbp), %rdi
callq 0x9ee0
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0xc8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0xd0(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9d70
movq -0xd0(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa2c0
movq %rax, -0x30(%rbp)
addq $0xe0, %rsp
popq %rbp
retq
jmp 0x4c40
leaq -0x18(%rbp), %rdi
callq 0x9f00
jmp 0x4bab
movb $0x1, -0xbd(%rbp)
movl $0x10, %edi
callq 0x4110
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x1d41e(%rip), %rsi     # 0x2208f
leaq -0xb0(%rbp), %rdi
callq 0xa3d0
jmp 0x4c7f
leaq 0x1d3fa(%rip), %rdx     # 0x22080
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xa330
jmp 0x4c9b
movq -0xc8(%rbp), %rdx
addq $0x8, %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xa380
jmp 0x4cb8
leaq 0x1d3d6(%rip), %rdx     # 0x22095
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa330
jmp 0x4cce
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4390
jmp 0x4ce0
movq -0xd8(%rbp), %rdi
movb $0x0, -0xbd(%rbp)
movq 0x292db(%rip), %rsi     # 0x2dfd0
movq 0x292c4(%rip), %rdx     # 0x2dfc0
callq 0x43e0
jmp 0x4db7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4d92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4d7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4d71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4160
leaq -0x70(%rbp), %rdi
callq 0x4160
leaq -0x90(%rbp), %rdi
callq 0x4160
leaq -0xb0(%rbp), %rdi
callq 0x4160
testb $0x1, -0xbd(%rbp)
jne 0x4d9d
jmp 0x4da9
movq -0xd8(%rbp), %rdi
callq 0x41a0
jmp 0x4dab
movq -0xb8(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::judge(std::pair<float, float> const&, bool*) const
bool Obj::judge(const Fpair& pt, bool *val) const { // returned value: if pt=(x,y) is in the governing region; val: if pt=(x,y) gets solid printed.
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) for(auto rit = objs.rbegin(); rit != objs.rend(); ++rit) if((*rit)->judge(pt, val)) return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movss 0x40(%rax), %xmm1
movss 0x29223(%rip), %xmm0    # 0x2e28c
ucomiss %xmm1, %xmm0
jb 0x5129
movq -0x38(%rbp), %rax
movss 0x2920e(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5129
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x50a6
jmp 0x5127
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x38, %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x50bd
jmp 0x5127
movq -0x38(%rbp), %rsi
addq $0x48, %rsi
leaq -0x28(%rbp), %rdi
callq 0xa620
movq -0x38(%rbp), %rsi
addq $0x48, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa6a0
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa670
testb $0x1, %al
jne 0x50f2
jmp 0x5125
leaq -0x28(%rbp), %rdi
callq 0xa6f0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x5112
jmp 0x5118
movb $0x1, -0x1(%rbp)
jmp 0x512d
jmp 0x511a
leaq -0x28(%rbp), %rdi
callq 0xa720
jmp 0x50ce
jmp 0x5127
jmp 0x5129
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Obj::update()
void Obj::update(void) {
	if(TimeNow < tlim.second) {
		for(auto p: motions) p->act(this);
		lower = {wid_ht,1}; upper = {-wid_ht,-1};
		for(auto p: objs) {
			p->update();
			union_pt(lower, upper, p->lower, p->upper);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movss 0x29130(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x52bf
movq -0x70(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9f80
testb $0x1, %al
jne 0x51a3
jmp 0x51cc
leaq -0x18(%rbp), %rdi
callq 0x9fc0
movq -0x70(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x18(%rbp), %rdi
callq 0x9fe0
jmp 0x5190
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x290aa(%rip), %rsi     # 0x2e288
leaq -0x34(%rbp), %rdx
callq 0x9c20
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
callq 0xa750
movss 0x29088(%rip), %xmm0    # 0x2e288
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
leaq -0x3c(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x9bf0
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
leaq -0x3c(%rbp), %rsi
callq 0xa750
movq -0x70(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9e70
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9d40
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9ea0
testb $0x1, %al
jne 0x5274
jmp 0x52bd
leaq -0x58(%rbp), %rdi
callq 0x9ee0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x70(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x38, %rsi
movq -0x68(%rbp), %rdx
addq $0x30, %rdx
movq -0x68(%rbp), %rcx
addq $0x38, %rcx
callq 0xa780
leaq -0x58(%rbp), %rdi
callq 0x9f00
jmp 0x5261
jmp 0x52bf
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: IntObj::copy() const
Obj* IntObj::copy() const {
	IntObj* res = new IntObj(*this);
	for(int i=0; i<objs.size(); ++i) res->objs[i] = res->objs[i]->copy();
	for(int i=0; i<motions.size(); ++i) res->motions[i] = res->motions[i]->copy();
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x80, %edi
callq 0x4270
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xaa60
jmp 0x5663
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x48, %rdi
callq 0xa0c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x56f0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movslq -0x20(%rbp), %rsi
callq 0xa0e0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movslq -0x20(%rbp), %rsi
callq 0xa0e0
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5672
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x80, %esi
callq 0x4280
jmp 0x5763
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x60, %rdi
callq 0xa100
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x5759
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa120
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa120
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x56f7
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: IntObj::judge(std::pair<float, float> const&, bool*) const
bool IntObj::judge(const Fpair& pt, bool *val) const { // returned value: if pt=(x,y) is in the governing region; val: if pt=(x,y) gets solid printed.
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			auto rit = objs.rbegin();
			for(; rit != objs.rend(); ++rit) if(!((*rit)->judge(pt))) break;
			if(rit == objs.rend()) gov = true;
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// 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, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
movss 0x40(%rax), %xmm1
movss 0x28aef(%rip), %xmm0    # 0x2e28c
ucomiss %xmm1, %xmm0
jb 0x5882
movq -0x40(%rbp), %rax
movss 0x28ada(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5882
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x57da
jmp 0x5880
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x38, %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x57f4
jmp 0x5880
movq -0x40(%rbp), %rsi
addq $0x48, %rsi
leaq -0x28(%rbp), %rdi
callq 0xa620
movq -0x40(%rbp), %rsi
addq $0x48, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa6a0
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa670
testb $0x1, %al
jne 0x5829
jmp 0x5856
leaq -0x28(%rbp), %rdi
callq 0xa6f0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %edx
callq *0x20(%rax)
testb $0x1, %al
jne 0x5849
jmp 0x5856
jmp 0x584b
leaq -0x28(%rbp), %rdi
callq 0xa720
jmp 0x5805
movq -0x40(%rbp), %rsi
addq $0x48, %rsi
leaq -0x38(%rbp), %rdi
callq 0xa6a0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaab0
testb $0x1, %al
jne 0x587a
jmp 0x587e
movb $0x1, -0x19(%rbp)
jmp 0x5880
jmp 0x5882
cmpq $0x0, -0x18(%rbp)
je 0x58b2
movq -0x40(%rbp), %rcx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x78(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: IntObj::update()
void IntObj::update(void) {
	if(TimeNow < tlim.second) {
		for(auto p: motions) p->act(this);
		lower = {-wid_ht,-1}; upper = {wid_ht,1};
		for(auto p: objs) {
			p->update();
			intersect_pt(lower, upper, p->lower, p->upper);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movss 0x289b0(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5a3f
movq -0x70(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9f80
testb $0x1, %al
jne 0x5923
jmp 0x594c
leaq -0x18(%rbp), %rdi
callq 0x9fc0
movq -0x70(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x18(%rbp), %rdi
callq 0x9fe0
jmp 0x5910
movss 0x28934(%rip), %xmm0    # 0x2e288
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x9bf0
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
callq 0xa750
movl $0x1, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x288e7(%rip), %rsi     # 0x2e288
leaq -0x44(%rbp), %rdx
callq 0x9c20
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
leaq -0x40(%rbp), %rsi
callq 0xa750
movq -0x70(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9e70
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9d40
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9ea0
testb $0x1, %al
jne 0x59f4
jmp 0x5a3d
leaq -0x58(%rbp), %rdi
callq 0x9ee0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x70(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x38, %rsi
movq -0x68(%rbp), %rdx
addq $0x30, %rdx
movq -0x68(%rbp), %rcx
addq $0x38, %rcx
callq 0xaaf0
leaq -0x58(%rbp), %rdi
callq 0x9f00
jmp 0x59e1
jmp 0x5a3f
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Frame::play(float)
void Frame::play(float time_end) {
	int c; bool val; float x, y;
	do {
		TimeNow += time_intv;
		this->update();
		y = 1;
		for(int j=0; j<FrameHeight; ++j) {
			x = -wid_ht;
			for(int i=0; i<FrameWidth; ++i) {
				c = 0;
				for(int n=0; n<3; ++n) {
					if(!this->judge({x, y-n*y_intv}, &val)) val = false;
					c ^= val<<n;
				}
				cout << c[" ''*.'u$"]; // cout << c[" ''\".$u$"];
				x += x_intv;
			}
			cout << '\n';
			y -= 3*y_intv;
		}
		usleep(time_intv*1000000); cout << rewindstr;
	} while(TimeNow < time_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movss 0x78(%rdi), %xmm0
addss 0x285d2(%rip), %xmm0    # 0x2e28c
movss %xmm0, 0x285ca(%rip)    # 0x2e28c
movq (%rdi), %rax
callq *0x28(%rax)
movss 0x1c370(%rip), %xmm0    # 0x22040
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x2859f(%rip), %eax     # 0x2e284
jge 0x5e34
movss 0x28595(%rip), %xmm0    # 0x2e288
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x2856b(%rip), %eax     # 0x2e280
jge 0x5def
movl $0x0, -0x10(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x5db3
movq -0x40(%rbp), %rax
movss -0x1c(%rbp), %xmm1
cvtsi2ssl -0x28(%rbp), %xmm0
movss 0x80(%rax), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0xae50
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
leaq -0x30(%rbp), %rsi
leaq -0x11(%rbp), %rdx
callq *0x20(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d8e
jmp 0x5d92
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl -0x28(%rbp), %ecx
shll %cl, %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5d29
movslq -0x10(%rbp), %rcx
movq 0x281fa(%rip), %rdi     # 0x2dfb8
leaq 0x1c2de(%rip), %rax     # 0x220a3
movsbl (%rax,%rcx), %esi
callq 0x4310
movq -0x40(%rbp), %rax
movss 0x7c(%rax), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5d0c
movq 0x281c2(%rip), %rdi     # 0x2dfb8
movl $0xa, %esi
callq 0x4310
movq -0x40(%rbp), %rax
movss 0x80(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
movss 0x1c22f(%rip), %xmm2    # 0x22048
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5cdc
movq -0x40(%rbp), %rax
movss 0x78(%rax), %xmm0
movss 0x1c1ff(%rip), %xmm1    # 0x22044
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, %edi
callq 0x4360
movq -0x40(%rbp), %rsi
addq $0x88, %rsi
movq 0x28151(%rip), %rdi     # 0x2dfb8
callq 0x4250
movss 0x28418(%rip), %xmm1    # 0x2e28c
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
ja 0x5ca9
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::judge(std::pair<float, float> const&, bool*) const
bool Line::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second) {
		float dist = v*pt;
		gov = (dist > intsc) && (dist <= intsc+width);
	}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movss 0x40(%rax), %xmm1
movss 0x281af(%rip), %xmm0    # 0x2e28c
ucomiss %xmm1, %xmm0
jb 0x614c
movq -0x28(%rbp), %rax
movss 0x2819e(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x614c
movq -0x28(%rbp), %rdi
addq $0x84, %rdi
movq -0x10(%rbp), %rsi
callq 0xaf60
movq -0x28(%rbp), %rcx
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
xorl %eax, %eax
ucomiss 0x7c(%rcx), %xmm0
movb %al, -0x29(%rbp)
jbe 0x6144
movq -0x28(%rbp), %rax
movss -0x20(%rbp), %xmm1
movss 0x7c(%rax), %xmm0
addss 0x80(%rax), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x617f
movq -0x28(%rbp), %rcx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x8c(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::rotate(float, std::pair<float, float> const&)
Line* Line::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt(pc, pr, dangle);
	angle += dangle;
	dangle = v*pr - intsc;
	v = {cos(angle), sin(angle)};
	intsc = v*pr - dangle;
	return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movss -0xc(%rbp), %xmm0
callq 0xa910
movq -0x30(%rbp), %rdi
movss -0xc(%rbp), %xmm0
addss 0x78(%rdi), %xmm0
movss %xmm0, 0x78(%rdi)
addq $0x84, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf60
movq -0x30(%rbp), %rax
subss 0x7c(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x78(%rax), %xmm0
callq 0xae80
movq -0x30(%rbp), %rax
movss %xmm0, -0x24(%rbp)
movss 0x78(%rax), %xmm0
callq 0xaea0
movss %xmm0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xaec0
movq -0x30(%rbp), %rdi
addq $0x84, %rdi
leaq -0x20(%rbp), %rsi
callq 0xa750
movq -0x30(%rbp), %rdi
addq $0x84, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf60
movq -0x30(%rbp), %rax
subss -0xc(%rbp), %xmm0
movss %xmm0, 0x7c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::scale(float, std::pair<float, float> const&)
Line* Line::scale(float rate, const Fpair& ps) {
	scl_pt_pt(pc, ps, rate);
	intsc = (1-rate)*(v*ps) + intsc*rate;
	width *= rate;
	return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movss -0xc(%rbp), %xmm0
callq 0xa9e0
movq -0x28(%rbp), %rdi
movss 0x1bcc5(%rip), %xmm0    # 0x22040
subss -0xc(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
addq $0x84, %rdi
movq -0x18(%rbp), %rsi
callq 0xaf60
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm2
movss -0x1c(%rbp), %xmm0
movss 0x7c(%rax), %xmm1
mulss -0xc(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x7c(%rax)
movss -0xc(%rbp), %xmm0
mulss 0x80(%rax), %xmm0
movss %xmm0, 0x80(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Line::scale(float)
Line* Line::scale(float rate) { // expand/shrink wrt the centerline
	intsc += (1-rate)/2*width;
	width *= rate;
	return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x1bc47(%rip), %xmm0    # 0x22040
subss -0xc(%rbp), %xmm0
movss 0x1bc46(%rip), %xmm1    # 0x2204c
divss %xmm1, %xmm0
movss 0x80(%rax), %xmm2
movss 0x7c(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x7c(%rax)
movss -0xc(%rbp), %xmm0
mulss 0x80(%rax), %xmm0
movss %xmm0, 0x80(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Triangle::judge(std::pair<float, float> const&, bool*) const
bool Triangle::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			Fpair v = pt - p0;
			float v1v_v1v2 = cross(v1, v) / v1v2,
				  vv2_v1v2 = cross(v, v2) / v1v2;
			gov = ((v1v_v1v2 >= 0) && (vv2_v1v2 >= 0) && (v1v_v1v2 + vv2_v1v2 <= 1));
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// 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)
movb $0x0, -0x19(%rbp)
movss 0x40(%rax), %xmm1
movss 0x277ef(%rip), %xmm0    # 0x2e28c
ucomiss %xmm1, %xmm0
jb 0x6b99
movq -0x38(%rbp), %rax
movss 0x277da(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x6b99
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x6ada
jmp 0x6b97
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x38, %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x6af4
jmp 0x6b97
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x78, %rsi
callq 0xa8b0
movq -0x38(%rbp), %rdi
movlpd %xmm0, -0x24(%rbp)
addq $0x90, %rdi
leaq -0x24(%rbp), %rsi
callq 0xb030
movq -0x38(%rbp), %rsi
divss 0xa0(%rsi), %xmm0
movss %xmm0, -0x28(%rbp)
addq $0x98, %rsi
leaq -0x24(%rbp), %rdi
callq 0xb030
movq -0x38(%rbp), %rax
divss 0xa0(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x39(%rbp)
jb 0x6b8f
movss -0x2c(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x39(%rbp)
jb 0x6b8f
movss -0x28(%rbp), %xmm1
addss -0x2c(%rbp), %xmm1
movss 0x1b4ba(%rip), %xmm0    # 0x22040
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6b99
cmpq $0x0, -0x18(%rbp)
je 0x6bcc
movq -0x38(%rbp), %rcx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0xa4(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Triangle::rotate(float, std::pair<float, float> const&)
Triangle* Triangle::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt({&p0, &p1, &p2, &pc}, pr, dangle);
	v1 = p1 - p0; v2 = p2 - p0;
	// v1v2 is unchanged
	this->set_lim(); return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rax, %rcx
addq $0x78, %rcx
movq %rcx, -0x68(%rbp)
movq %rcx, -0x48(%rbp)
movq %rax, %rcx
subq $-0x80, %rcx
movq %rcx, -0x78(%rbp)
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0x88, %rcx
movq %rcx, -0x70(%rbp)
movq %rcx, -0x38(%rbp)
addq $0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb260
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xa8b0
movq -0x60(%rbp), %rdi
movlpd %xmm0, -0x50(%rbp)
addq $0x90, %rdi
leaq -0x50(%rbp), %rsi
callq 0xa750
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xa8b0
movq -0x60(%rbp), %rdi
movlpd %xmm0, -0x58(%rbp)
addq $0x98, %rdi
leaq -0x58(%rbp), %rsi
callq 0xa750
movq -0x60(%rbp), %rdi
callq 0x6440
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Triangle::scale(float, std::pair<float, float> const&)
Triangle* Triangle::scale(float rate, const Fpair& ps) {
	scl_pt_pt({&p0, &p1, &p2, &pc, &lower, &upper}, ps, rate);
	if(rate < 0) swap(lower, upper);
	v1 *= rate; v2 *= rate; v1v2 *= (rate*rate);
	return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rax, %rcx
addq $0x78, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, %rcx
addq $0x80, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, %rcx
addq $0x88, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x38(%rbp)
addq $0x38, %rax
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x6, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb3c0
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x6e85
movq -0x60(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x38, %rsi
callq 0xb480
movq -0x60(%rbp), %rdi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addq $0x90, %rdi
callq 0xb4b0
movq -0x60(%rbp), %rdi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addq $0x98, %rdi
callq 0xb4b0
movq -0x60(%rbp), %rax
movss -0xc(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
mulss 0xa0(%rax), %xmm0
movss %xmm0, 0xa0(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rectangle::judge(std::pair<float, float> const&, bool*) const
bool Rectangle::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) gov = (l1.judge(pt) && l2.judge(pt));
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movss 0x40(%rax), %xmm1
movss 0x2656f(%rip), %xmm0    # 0x2e28c
ucomiss %xmm1, %xmm0
jb 0x7db5
movq -0x28(%rbp), %rax
movss 0x2655a(%rip), %xmm1    # 0x2e28c
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7db5
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x7d53
jmp 0x7db3
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x38, %rsi
callq 0xa5d0
testb $0x1, %al
jne 0x7d6a
jmp 0x7db3
movq -0x28(%rbp), %rdi
addq $0x98, %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x60b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x7d90
jmp 0x7dab
movq -0x28(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x60b0
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x7db5
cmpq $0x0, -0x18(%rbp)
je 0x7de8
movq -0x28(%rbp), %rcx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x1b8(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rectangle::rotate(float, std::pair<float, float> const&)
Rectangle* Rectangle::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt({&pc0, &pc}, pr, dangle);
	l1.rotate(dangle, pr); l2.rotate(dangle, pr);
	angle += dangle;
	v = {cos(angle), sin(angle)};
	this->set_lim();
	return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, %rcx
addq $0x78, %rcx
movq %rcx, -0x38(%rbp)
addq $0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x2, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb260
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x6270
movq -0x50(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x6270
movq -0x50(%rbp), %rax
movss -0xc(%rbp), %xmm0
addss 0x90(%rax), %xmm0
movss %xmm0, 0x90(%rax)
movss 0x90(%rax), %xmm0
callq 0xae80
movq -0x50(%rbp), %rax
movss %xmm0, -0x44(%rbp)
movss 0x90(%rax), %xmm0
callq 0xaea0
movss %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xaec0
movq -0x50(%rbp), %rdi
addq $0x80, %rdi
leaq -0x40(%rbp), %rsi
callq 0xa750
movq -0x50(%rbp), %rdi
callq 0x7420
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rectangle::scale(float, std::pair<float, float> const&)
Rectangle* Rectangle::scale(float rate, const Fpair& ps) {
	scl_pt_pt({&pc0, &pc, &lower, &upper}, ps, rate);
	if(rate < 0) swap(lower, upper);
	wid1 *= rate; wid2 *= rate;
	l1.scale(rate, ps); l2.scale(rate, ps);
	return this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, %rcx
addq $0x78, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x38(%rbp)
addq $0x38, %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb3c0
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x80b9
movq -0x50(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x38, %rsi
callq 0xb480
movq -0x50(%rbp), %rdi
movss -0xc(%rbp), %xmm0
mulss 0x88(%rdi), %xmm0
movss %xmm0, 0x88(%rdi)
movss -0xc(%rbp), %xmm0
mulss 0x8c(%rdi), %xmm0
movss %xmm0, 0x8c(%rdi)
addq $0x98, %rdi
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x6340
movq -0x50(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x6340
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::set_lim()
void Ellipse::set_lim(void) {
	float delta = sqrt(asq*v.first*v.first + bsq*v.second*v.second);
	lower.first = pc0.first - delta; upper.first = pc0.first + delta;
	delta = sqrt(asq*v.second*v.second + bsq*v.first*v.first);
	lower.second = pc0.second - delta; upper.second = pc0.second + delta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movss 0x88(%rax), %xmm0
mulss 0x80(%rax), %xmm0
movss 0x80(%rax), %xmm2
movss 0x8c(%rax), %xmm1
mulss 0x84(%rax), %xmm1
mulss 0x84(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xb660
movq -0x18(%rbp), %rax
movss %xmm0, -0xc(%rbp)
movss 0x78(%rax), %xmm0
subss -0xc(%rbp), %xmm0
movss %xmm0, 0x30(%rax)
movss 0x78(%rax), %xmm0
addss -0xc(%rbp), %xmm0
movss %xmm0, 0x38(%rax)
movss 0x88(%rax), %xmm0
mulss 0x84(%rax), %xmm0
movss 0x84(%rax), %xmm2
movss 0x8c(%rax), %xmm1
mulss 0x80(%rax), %xmm1
mulss 0x80(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xb660
movq -0x18(%rbp), %rax
movss %xmm0, -0xc(%rbp)
movss 0x7c(%rax), %xmm0
subss -0xc(%rbp), %xmm0
movss %xmm0, 0x34(%rax)
movss 0x7c(%rax), %xmm0
addss -0xc(%rbp), %xmm0
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)