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

    if (TYPE == TYPE_OP && VALUE.op == OPENING_ROUND_BRACKET)
    {
        CheckOpeningRoundBracket(parser, ofs);
        Node* tmp = GetExpression(parser, ofs);
        CheckClosingRoundBracket(parser, ofs);

        return tmp;
    }

    if (TYPE == TYPE_ID)
    {
        if (NEXT_TYPE == TYPE_OP && NEXT_VALUE.op == OPENING_ROUND_BRACKET) // call
        {
            Node* tmp = ID(nullptr, nullptr);
            return ConstructNode(CALL_TYPE, tmp, GetParams(parser, ofs));             
        }
        else if (NEXT_TYPE == TYPE_OP && NEXT_VALUE.op == OPENING_SQUARE_BRACKET)
        {
            return GetMemoryAccess(parser, ofs);
        }
        else
        {
            return ID(nullptr, nullptr);
        }
    }

    int val = VALUE.number;
    (*ofs)++;

    return ConstructNode(NUMB_TYPE, { .number = val });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6e9b
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
movq (%rsi), %rax
imulq $0x18, %rax, %rsi
leaq (%rdx,%rsi), %rcx
movl (%rdx,%rsi), %edi
cmpl $0x1, %edi
je 0x6df6
cmpl $0x2, %edi
jne 0x6e45
movl 0x8(%rcx), %ecx
cmpl $0x13, %ecx
jne 0x6e48
movq %r14, %rdi
movq %rbx, %rsi
callq 0x639f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6404
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incq %rax
imulq $0x18, %rax, %rdi
cmpl $0x2, (%rdx,%rdi)
jne 0x6e7d
addq %rdx, %rdi
cmpl $0x13, 0x8(%rdi)
jne 0x6e62
movq %rax, (%rbx)
movq 0x8(%rcx), %rsi
pushq $0x4
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6eba
pushq $0xc
popq %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5f8e
movl 0x8(%rcx), %ecx
incq %rax
movq %rax, (%rbx)
movl %ecx, %esi
pushq $0xf
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5fa0
cmpl $0x15, 0x20(%rcx)
jne 0x6e7d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6f88
movq %rax, (%rbx)
movq 0x8(%rdx,%rsi), %rsi
pushq $0x4
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5ee3
leaq 0x25d4(%rip), %rdi      # 0x9476
leaq 0x30d8(%rip), %rsi      # 0x9f81
leaq 0x3337(%rip), %rcx      # 0xa1e7
movl $0x184, %edx            # imm = 0x184
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6f69
movq %rsi, %rbx
movq %rdi, %r14
callq 0x639f
movq (%r14), %rax
imulq $0x18, (%rbx), %rcx
cmpl $0x2, (%rax,%rcx)
jne 0x6f09
addq %rcx, %rax
cmpl $0x14, 0x8(%rax)
jne 0x6f09
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6404
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
pushq $0x5
popq %r12
movl %r12d, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x5f8e
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
imulq $0x18, %rax, %rdx
cmpl $0x2, (%rcx,%rdx)
jne 0x6ef2
addq %rdx, %rcx
cmpl $0x18, 0x8(%rcx)
jne 0x6ef2
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
movl %r12d, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x5f8e
movq %rax, 0x10(%r15)
movq %r15, 0x20(%rax)
jmp 0x6f25
leaq 0x2506(%rip), %rdi      # 0x9476
leaq 0x300a(%rip), %rsi      # 0x9f81
leaq 0x32e4(%rip), %rcx      # 0xa262
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6ffd
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
imulq $0x18, %rcx, %rcx
movq 0x8(%rax,%rcx), %rsi
pushq $0x4
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5ee3
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a07
movq %r14, %rdi
movq %rbx, %rsi
callq 0x696c
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a6c
pushq $0x3
popq %rdi
movq %r15, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5f8e
leaq 0x2472(%rip), %rdi      # 0x9476
leaq 0x2f76(%rip), %rsi      # 0x9f81
leaq 0x3204(%rip), %rcx      # 0xa216
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7061
testq %rsi, %rsi
je 0x707a
movq %rdi, %rbx
leaq 0x18c3(%rip), %rax      # 0x88fa
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2130
testq %rax, %rax
je 0x7093
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x70b0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
leaq 0x1bf2(%rip), %rdi      # 0x8c5a
leaq 0x3421(%rip), %rsi      # 0xa490
leaq 0x3433(%rip), %rcx      # 0xa4a9
pushq $0x9
jmp 0x70aa
leaq 0x344f(%rip), %rdi      # 0xa4d0
leaq 0x3408(%rip), %rsi      # 0xa490
leaq 0x341a(%rip), %rcx      # 0xa4a9
pushq $0xa
jmp 0x70aa
leaq 0x1866(%rip), %rdi      # 0x8900
leaq 0x33ef(%rip), %rsi      # 0xa490
leaq 0x3401(%rip), %rcx      # 0xa4a9
pushq $0xd
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x71ad
movq %rdi, %r14
testq %rdi, %rdi
je 0x7108
movq %rsi, %rbx
movl (%r14), %edx
leaq 0x3427(%rip), %rsi      # 0xa503
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movl (%r14), %eax
cmpl $0x4, %eax
je 0x7117
cmpl $0xf, %eax
movl 0x8(%r14), %edx
leaq 0x340d(%rip), %rsi      # 0xa509
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
jmp 0x712c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
leaq 0x33eb(%rip), %rsi      # 0xa50d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
leaq 0x33de(%rip), %rdi      # 0xa511
pushq $0x2
popq %r15
pushq $0x1
popq %r12
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x21f0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x70b0
leaq 0x33b8(%rip), %r13      # 0xa514
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x21f0
leaq 0x339d(%rip), %rdi      # 0xa511
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x21f0
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x70b0
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
leaq 0x174c(%rip), %rdi      # 0x8900
leaq 0x32d5(%rip), %rsi      # 0xa490
leaq 0x3315(%rip), %rcx      # 0xa4d7
pushq $0x16
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7211
callq 0x5018
movq %rax, %rbx
callq 0x5e7d
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x5fa0
movq %rax, (%r14)
addq $0x5, (%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x722e
movq (%r14), %rdi
callq 0x738f
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x16e8(%rip), %rdi      # 0x8900
leaq 0x3271(%rip), %rsi      # 0xa490
leaq 0x32f1(%rip), %rcx      # 0xa517
pushq $0x38
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x73ea
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x73b1
callq 0x738f
movq 0x20(%rbx), %rax
jmp 0x73ba
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x73c9
movq %rax, %rbx
testq %rax, %rax
jne 0x7398
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpq %rbx, 0x18(%rax)
setne %cl
andq $0x0, 0x18(%rax,%rcx,8)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
leaq 0x2bb7(%rip), %rdi      # 0x9fa8
leaq 0x3098(%rip), %rsi      # 0xa490
leaq 0x318c(%rip), %rcx      # 0xa58b
movl $0x85, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
xorl %ecx, %ecx
leaq 0x96696(%rip), %r8      # 0x4980d0
movw $0x9, %r9w
leaq 0x9669a(%rip), %r10     # 0x4980e0
xorl %r11d, %r11d
cmpq $0xa, %r11
je 0x401a89
movzwl (%r11,%r8), %ebx
movl %esi, %eax
xorl %edx, %edx
divw %bx
xorl %edx, %edx
divw %r9w
movzwl %dx, %r14d
movl %edi, %eax
xorl %edx, %edx
divw %bx
xorl %edx, %edx
divw %r9w
imulq $0x12, %r14, %rax
addq %r10, %rax
movzwl %dx, %edx
imulw (%rax,%rdx,2), %bx
addl %ebx, %ecx
addq $0x2, %r11
jmp 0x401a49
movl %ecx, %eax
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x78
popq %rdi
callq 0x31d0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x608c
xorl %r15d, %r15d
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x35d9
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x35ad
xorl %r15d, %r15d
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x3608
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x60(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x35dc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x31e0
movq %r14, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x48(%rdi), %rbx
movq 0x48(%rdi), %r12
cmpq 0x50(%r14), %r12
je 0x36e6
movq (%r12), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0x613c
testb %al, %al
jne 0x36c3
addq $0x8, %r12
jmp 0x36a3
movq (%r12), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
movq %r12, %rsi
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6166
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0xa9af(%rip), %rsi      # 0xe0a7
movq %rsp, %rdi
movq %r15, %rdx
callq 0x61dd
leaq 0xa98e(%rip), %rdx      # 0xe098
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x619f
addq $0x8, %r14
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x61be
leaq 0xa979(%rip), %rdx      # 0xe0ad
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x619f
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x3280
xorl %ebp, %ebp
movq 0x10874(%rip), %rsi     # 0x13fd0
movq 0x1085d(%rip), %rdx     # 0x13fc0
movq %rbx, %rdi
callq 0x32d0
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x30d0
jmp 0x3780
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x30d0
jmp 0x3792
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x30d0
jmp 0x37a4
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x30d0
testb %bpl, %bpl
jne 0x37b6
jmp 0x37be
movq %rax, %r14
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movss 0x10894(%rip), %xmm0    # 0x141dc
xorl %ebp, %ebp
ucomiss 0x40(%rdi), %xmm0
jb 0x39bc
movq %rdi, %r15
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x39bc
movq %rsi, %r14
movss (%rsi), %xmm0
xorl %ebp, %ebp
ucomiss 0x30(%r15), %xmm0
jb 0x39bc
movss 0x4(%r14), %xmm1
ucomiss 0x34(%r15), %xmm1
jb 0x39bc
movss 0x38(%r15), %xmm2
xorl %ebp, %ebp
ucomiss %xmm0, %xmm2
jb 0x39bc
movss 0x3c(%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x39bc
movq %rdx, %rbx
movq 0x50(%r15), %r12
cmpq 0x48(%r15), %r12
setne %bpl
je 0x39bc
movq -0x8(%r12), %rdi
addq $-0x8, %r12
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x3999
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movss 0x44(%rdi), %xmm0
ucomiss 0x10808(%rip), %xmm0    # 0x141dc
jbe 0x3a77
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rbx
movq 0x68(%rdi), %r15
cmpq %r15, %rbx
je 0x3a05
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
addq $0x8, %rbx
jmp 0x39ee
movss 0x107cb(%rip), %xmm0    # 0x141d8
leaq 0x30(%r14), %rbx
movss %xmm0, 0x30(%r14)
movl $0x3f800000, 0x34(%r14) # imm = 0x3F800000
xorps 0xa5ea(%rip), %xmm0     # 0xe010
leaq 0x38(%r14), %r15
movss %xmm0, 0x38(%r14)
movl $0xbf800000, 0x3c(%r14) # imm = 0xBF800000
movq 0x48(%r14), %r12
movq 0x50(%r14), %r13
cmpq %r13, %r12
je 0x3a6e
movq (%r12), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
leaq 0x30(%r14), %rdx
addq $0x38, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x62af
addq $0x8, %r12
jmp 0x3a40
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x80, %edi
callq 0x31d0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x63c2
xorl %r15d, %r15d
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x3c49
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x3c1d
xorl %r15d, %r15d
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x3c78
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x60(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x3c4c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x31e0
movq %r14, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movss 0x1052b(%rip), %xmm0    # 0x141dc
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x3d2e
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3d2e
movq %rsi, %r15
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%r14), %xmm0
jb 0x3d2e
movss 0x4(%r15), %xmm1
ucomiss 0x34(%r14), %xmm1
jb 0x3d2e
movss 0x38(%r14), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x3d2e
movss 0x3c(%r14), %xmm0
ucomiss %xmm1, %xmm0
jb 0x3d2e
movq 0x50(%r14), %r13
movq %r13, %r12
cmpq 0x48(%r14), %r13
je 0x3d25
leaq -0x8(%r12), %r13
movq -0x8(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
xorl %edx, %edx
callq *0x20(%rax)
testb %al, %al
jne 0x3cfd
movq 0x48(%r14), %rax
jmp 0x3d28
movq %r12, %rax
cmpq %rax, %r12
sete %al
testq %rbx, %rbx
je 0x3d3a
cmpb %al, 0x78(%r14)
sete (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movss 0x44(%rdi), %xmm0
ucomiss 0x1048c(%rip), %xmm0    # 0x141dc
jbe 0x3df2
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %r15
cmpq %r15, %r14
je 0x3d81
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r14
jmp 0x3d6a
movss 0x1044f(%rip), %xmm0    # 0x141d8
movaps 0xa280(%rip), %xmm1     # 0xe010
xorps %xmm0, %xmm1
leaq 0x30(%rbx), %r14
movss %xmm1, 0x30(%rbx)
movl $0xbf800000, 0x34(%rbx) # imm = 0xBF800000
leaq 0x38(%rbx), %r15
movss %xmm0, 0x38(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
movq 0x48(%rbx), %r12
movq 0x50(%rbx), %r13
cmpq %r13, %r12
je 0x3de9
movq (%r12), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
leaq 0x30(%rbx), %rdx
addq $0x38, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x63ea
addq $0x8, %r12
jmp 0x3dbb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x88(%rdi), %rax
movq %rax, 0x30(%rsp)
movss 0x10263(%rip), %xmm0    # 0x141dc
leaq 0x18(%rsp), %r12
leaq 0xb(%rsp), %r13
addss 0x78(%rbx), %xmm0
movss %xmm0, 0x1024c(%rip)    # 0x141dc
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
xorl %eax, %eax
movss 0xa0cd(%rip), %xmm0     # 0xe070
movss %xmm0, 0xc(%rsp)
cmpl 0x10225(%rip), %eax     # 0x141d4
jge 0x40a7
movl %eax, 0x14(%rsp)
movss 0x10217(%rip), %xmm0    # 0x141d8
xorps 0xa048(%rip), %xmm0     # 0xe010
movaps %xmm0, 0x20(%rsp)
xorl %ebp, %ebp
cmpl 0x101fb(%rip), %ebp     # 0x141d0
jge 0x406d
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpl $0x3, %r14d
je 0x403d
cvtsi2ss %r14d, %xmm0
mulss 0x80(%rbx), %xmm0
movss 0xc(%rsp), %xmm1
subss %xmm0, %xmm1
movaps 0x20(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x1c(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x4029
movzbl 0xb(%rsp), %eax
jmp 0x4030
movb $0x0, 0xb(%rsp)
xorl %eax, %eax
movl %r14d, %ecx
shll %cl, %eax
xorl %eax, %r15d
incl %r14d
jmp 0x3fe1
movslq %r15d, %rax
leaq 0xa074(%rip), %rcx      # 0xe0bb
movsbl (%rax,%rcx), %esi
movq 0xff66(%rip), %rdi      # 0x13fb8
callq 0x3210
movaps 0x20(%rsp), %xmm0
addss 0x7c(%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
incl %ebp
jmp 0x3fcf
movq 0xff44(%rip), %rdi      # 0x13fb8
pushq $0xa
popq %rsi
callq 0x3210
movss 0x80(%rbx), %xmm0
mulss 0x9fec(%rip), %xmm0     # 0xe078
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movl 0x14(%rsp), %eax
incl %eax
jmp 0x3fa9
movss 0x78(%rbx), %xmm0
mulss 0x9fc0(%rip), %xmm0     # 0xe074
cvttss2si %xmm0, %rdi
callq 0x3260
movq 0xfef3(%rip), %rdi      # 0x13fb8
movq 0x30(%rsp), %rsi
callq 0x31b0
movss 0x10105(%rip), %xmm0    # 0x141dc
movss 0x10(%rsp), %xmm1
ucomiss %xmm0, %xmm1
ja 0x3f83
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movss 0xffd0(%rip), %xmm0     # 0x141dc
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x425b
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x425b
movss 0x84(%rdi), %xmm0
movss 0x88(%rdi), %xmm1
mulss 0x4(%rsi), %xmm1
mulss (%rsi), %xmm0
movss 0x7c(%rdi), %xmm2
addss %xmm1, %xmm0
movss 0x80(%rdi), %xmm1
addss %xmm2, %xmm1
cmpltps %xmm0, %xmm2
cmpleps %xmm1, %xmm0
andps %xmm2, %xmm0
movd %xmm0, %eax
testq %rdx, %rdx
je 0x426e
movl %eax, %ecx
andb $0x1, %cl
cmpb %cl, 0x8c(%rdi)
sete (%rdx)
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movss %xmm0, (%rsp)
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x62f2
movss (%rsp), %xmm0
addss 0x78(%rbx), %xmm0
movss %xmm0, 0x78(%rbx)
movss 0x84(%rbx), %xmm1
movss 0x88(%rbx), %xmm2
mulss 0x4(%r14), %xmm2
mulss (%r14), %xmm1
addss %xmm2, %xmm1
subss 0x7c(%rbx), %xmm1
movss %xmm1, (%rsp)
callq 0x3140
movss %xmm0, 0x4(%rsp)
movss 0x78(%rbx), %xmm0
callq 0x3180
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x84(%rbx)
movss %xmm0, 0x88(%rbx)
mulss 0x4(%r14), %xmm0
mulss (%r14), %xmm1
addss %xmm0, %xmm1
subss (%rsp), %xmm1
movss %xmm1, 0x7c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movss %xmm0, 0x4(%rsp)
movq %rdi, %r14
addq $0x28, %rdi
callq 0x6372
movss 0x9cc3(%rip), %xmm0     # 0xe070
movss 0x4(%rsp), %xmm3
subss %xmm3, %xmm0
movss 0x84(%r14), %xmm1
movss 0x88(%r14), %xmm2
mulss 0x4(%rbx), %xmm2
mulss (%rbx), %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm1
movss 0x7c(%r14), %xmm0
movaps %xmm3, %xmm2
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x7c(%r14)
mulss 0x80(%r14), %xmm2
movss %xmm2, 0x80(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movss 0x9c57(%rip), %xmm1     # 0xe070
subss %xmm0, %xmm1
mulss 0x9c57(%rip), %xmm1     # 0xe07c
movss 0x80(%rdi), %xmm2
mulss %xmm2, %xmm1
addss 0x7c(%rdi), %xmm1
movss %xmm1, 0x7c(%rdi)
mulss %xmm0, %xmm2
movss %xmm2, 0x80(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movss 0xfa7e(%rip), %xmm0     # 0x141dc
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x483d
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x483d
movsd (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%rdi), %xmm0
jb 0x483d
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x34(%rdi), %xmm1
jb 0x483d
movss 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x483d
movss 0x3c(%rdi), %xmm2
ucomiss %xmm1, %xmm2
jb 0x483d
movsd 0x78(%rdi), %xmm1
subps %xmm1, %xmm0
movaps %xmm0, %xmm2
shufps $0xe1, %xmm0, %xmm2     # xmm2 = xmm2[1,0],xmm0[2,3]
movss 0x94(%rdi), %xmm1
shufps $0xd4, %xmm0, %xmm1     # xmm1 = xmm1[0,1],xmm0[1,3]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
movss 0x98(%rdi), %xmm3
movss %xmm3, %xmm2            # xmm2 = xmm3[0],xmm2[1,2,3]
mulps %xmm1, %xmm2
movss 0x90(%rdi), %xmm3
movss 0x9c(%rdi), %xmm1
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
mulps %xmm0, %xmm1
subps %xmm2, %xmm1
movss 0xa0(%rdi), %xmm0
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
divps %xmm0, %xmm1
xorps %xmm0, %xmm0
cmpleps %xmm1, %xmm0
unpcklps %xmm0, %xmm0            # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x483b
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
movss 0x983d(%rip), %xmm1     # 0xe070
ucomiss %xmm0, %xmm1
setae %al
jmp 0x483d
xorl %eax, %eax
testq %rdx, %rdx
je 0x484b
cmpb %al, 0xa4(%rdi)
sete (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x80(%rbx), %rax
movq %rax, 0x8(%rdi)
leaq 0x88(%rbx), %rax
movq %rax, 0x10(%rdi)
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rdi)
pushq $0x4
popq %rsi
callq 0x658e
movsd 0x78(%rbx), %xmm0
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movups 0x80(%rbx), %xmm1
subps %xmm0, %xmm1
movups %xmm1, 0x90(%rbx)
movq %rbx, %rdi
callq 0x4448
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rdx
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x80(%rbx), %rax
movq %rax, 0x8(%rdi)
leaq 0x88(%rbx), %rax
movq %rax, 0x10(%rdi)
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rdi)
leaq 0x30(%rbx), %r14
movq %r14, 0x20(%rdi)
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rdi)
pushq $0x6
popq %rsi
callq 0x6619
xorps %xmm0, %xmm0
movss 0xc(%rsp), %xmm2
movaps %xmm2, %xmm1
ucomiss %xmm2, %xmm0
jbe 0x49d0
movups (%r14), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, (%r14)
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x90(%rbx), %rdi
callq 0x6692
leaq 0x98(%rbx), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x6692
movss 0xc(%rsp), %xmm0
mulss %xmm0, %xmm0
mulss 0xa0(%rbx), %xmm0
movss %xmm0, 0xa0(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movss 0xf2a0(%rip), %xmm0     # 0x141dc
xorl %r15d, %r15d
ucomiss 0x40(%rdi), %xmm0
jb 0x4fb4
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4fb4
movq %rsi, %r12
movss (%rsi), %xmm0
xorl %r15d, %r15d
ucomiss 0x30(%r14), %xmm0
jb 0x4fb4
movss 0x4(%r12), %xmm1
ucomiss 0x34(%r14), %xmm1
jb 0x4fb4
movss 0x38(%r14), %xmm2
xorl %r15d, %r15d
ucomiss %xmm0, %xmm2
jb 0x4fb4
movss 0x3c(%r14), %xmm0
ucomiss %xmm1, %xmm0
jb 0x4fb4
leaq 0x98(%r14), %rdi
xorl %r15d, %r15d
movq %r12, %rsi
xorl %edx, %edx
callq 0x4204
testb %al, %al
je 0x4fb4
leaq 0x128(%r14), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4204
movl %eax, %r15d
testq %rbx, %rbx
je 0x4fc3
cmpb %r15b, 0x1b8(%r14)
sete (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rbx), %rax
movq %rax, 0x8(%rdi)
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0x658e
leaq 0x98(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x42ec
leaq 0x128(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x42ec
movss 0x4(%rsp), %xmm0
addss 0x90(%rbx), %xmm0
movss %xmm0, 0x90(%rbx)
callq 0x3140
movss %xmm0, 0x4(%rsp)
movss 0x90(%rbx), %xmm0
callq 0x3180
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x80(%rbx)
movss %xmm0, 0x84(%rbx)
movq %rbx, %rdi
callq 0x4bee
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movaps %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rbx), %rax
movq %rax, 0x8(%rdi)
leaq 0x30(%rbx), %r15
movq %r15, 0x10(%rdi)
leaq 0x38(%rbx), %rax
movq %rax, 0x18(%rdi)
pushq $0x4
popq %rsi
movq %r14, %rdx
callq 0x6619
xorps %xmm0, %xmm0
movaps (%rsp), %xmm2
movaps %xmm2, %xmm1
ucomiss %xmm2, %xmm0
jbe 0x518f
movups (%r15), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, (%r15)
movsd 0x88(%rbx), %xmm2
movaps %xmm1, %xmm0
unpcklps %xmm1, %xmm1            # xmm1 = xmm1[0,0,1,1]
mulps %xmm2, %xmm1
movlps %xmm1, 0x88(%rbx)
leaq 0x98(%rbx), %rdi
movq %r14, %rsi
callq 0x438c
leaq 0x128(%rbx), %rdi
movaps (%rsp), %xmm0
movq %r14, %rsi
callq 0x438c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movss 0x80(%rdi), %xmm1
movss 0x84(%rdi), %xmm2
movss 0x88(%rdi), %xmm0
mulss %xmm1, %xmm0
movss 0x8c(%rdi), %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
addss %xmm3, %xmm0
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm0
jb 0x521c
sqrtss %xmm0, %xmm0
jmp 0x5224
callq 0x3310
xorps %xmm4, %xmm4
movss 0x78(%rbx), %xmm1
movss 0x80(%rbx), %xmm2
movaps %xmm1, %xmm3
subss %xmm0, %xmm3
movss %xmm3, 0x30(%rbx)
addss %xmm1, %xmm0
movss %xmm0, 0x38(%rbx)
movss 0x84(%rbx), %xmm1
movss 0x88(%rbx), %xmm0
mulss %xmm1, %xmm0
movss 0x8c(%rbx), %xmm3
mulss %xmm2, %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
addss %xmm3, %xmm0
ucomiss %xmm4, %xmm0
jb 0x527d
sqrtss %xmm0, %xmm0
jmp 0x5282
callq 0x3310
movss 0x7c(%rbx), %xmm1
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
movss %xmm2, 0x34(%rbx)
addss %xmm1, %xmm0
movss %xmm0, 0x3c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::judge(std::pair<float, float> const&, bool*) const
bool Ellipse::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			float dx = pt.first - pc0.first, dy = pt.second - pc0.second;
			gov = (pow(dx*v.first + dy*v.second, 2)/asq + pow(-dx*v.second + dy*v.first, 2)/bsq < 1);
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
movss 0xed54(%rip), %xmm0     # 0x141dc
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x552c
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x552c
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%rdi), %xmm0
jb 0x552c
movss 0x4(%rsi), %xmm1
ucomiss 0x34(%rdi), %xmm1
jb 0x552c
movss 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x552c
movss 0x3c(%rdi), %xmm2
ucomiss %xmm1, %xmm2
jb 0x552c
subss 0x78(%rdi), %xmm0
subss 0x7c(%rdi), %xmm1
movaps 0x8b30(%rip), %xmm2     # 0xe010
xorps %xmm0, %xmm2
movsd 0x80(%rdi), %xmm3
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
mulps %xmm3, %xmm0
shufps $0xe1, %xmm3, %xmm3     # xmm3 = xmm3[1,0,2,3]
mulps %xmm1, %xmm3
addps %xmm3, %xmm0
cvtps2pd %xmm0, %xmm0
mulpd %xmm0, %xmm0
cvtps2pd 0x88(%rdi), %xmm1
divpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8b6b(%rip), %xmm0     # 0xe090
ucomisd %xmm1, %xmm0
seta %al
testq %rdx, %rdx
je 0x553a
cmpb %al, 0x94(%rdi)
sete (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::rotate(float, std::pair<float, float> const&)
Ellipse* Ellipse::rotate(float dangle, const Fpair& pr) {
	rot_pt_pt({&pc0, &pc}, pr, dangle);
	angle += dangle;
	v = {cos(angle), sin(angle)};
	this->set_lim();
	return this;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rbx), %rax
movq %rax, 0x8(%rdi)
pushq $0x2
popq %rsi
callq 0x658e
movss 0xc(%rsp), %xmm0
addss 0x90(%rbx), %xmm0
movss %xmm0, 0x90(%rbx)
callq 0x3140
movss %xmm0, 0xc(%rsp)
movss 0x90(%rbx), %xmm0
callq 0x3180
movss 0xc(%rsp), %xmm1
movss %xmm1, 0x80(%rbx)
movss %xmm0, 0x84(%rbx)
movq %rbx, %rdi
callq 0x51d6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Ellipse::scale(float, std::pair<float, float> const&)
Ellipse* Ellipse::scale(float rate, const Fpair& ps) {
	float rate2 = rate*rate;
	asq *= rate2; bsq *= rate2;
	scl_pt_pt({&pc0, &pc, &lower, &upper}, ps, rate);
	if(rate < 0) swap(lower, upper);
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movaps %xmm0, %xmm2
movss %xmm0, 0x4(%rsp)
mulss %xmm0, %xmm2
movsd 0x88(%rdi), %xmm1
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm1, %xmm2
movlps %xmm2, 0x88(%rdi)
leaq 0x78(%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x28(%rbx), %rax
movq %rax, 0x8(%rdi)
leaq 0x30(%rbx), %r14
movq %r14, 0x10(%rdi)
leaq 0x38(%rbx), %rax
movq %rax, 0x18(%rdi)
pushq $0x4
popq %rsi
callq 0x6619
xorps %xmm0, %xmm0
ucomiss 0x4(%rsp), %xmm0
jbe 0x56af
movups (%r14), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, (%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: EllArc::judge(std::pair<float, float> const&, bool*) const
bool EllArc::judge(const Fpair& pt, bool *val) const {
	bool gov = false;
	if(tlim.first <= TimeNow && TimeNow < tlim.second)
		if(lower <= pt && pt <= upper) {
			float dx = pt.first - pc0.first, dy = pt.second - pc0.second, x = dx*v.first + dy*v.second, y = -dx*v.second + dy*v.first, dist2 = x*x/asq + y*y/bsq, ang;
			if(dist2 < 1 && dist2 >= 1-width) {
				ang = atan2(y, x);
				if(ang >= anglim1 && ang <= anglim2) gov = true;
			}
		}
	if(val!=nullptr) *val = !(gov^solid);
	return gov;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movss 0xe776(%rip), %xmm0     # 0x141dc
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x5b5e
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x5b5e
movss (%rsi), %xmm1
xorl %eax, %eax
ucomiss 0x30(%r14), %xmm1
jb 0x5b5e
movss 0x4(%rsi), %xmm0
ucomiss 0x34(%r14), %xmm0
jb 0x5b5e
movss 0x38(%r14), %xmm2
xorl %eax, %eax
ucomiss %xmm1, %xmm2
jb 0x5b5e
movss 0x3c(%r14), %xmm2
ucomiss %xmm0, %xmm2
jb 0x5b5e
subss 0x78(%r14), %xmm1
subss 0x7c(%r14), %xmm0
movaps 0x853b(%rip), %xmm2     # 0xe010
xorps %xmm1, %xmm2
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movsd 0x80(%r14), %xmm3
movsd 0x88(%r14), %xmm4
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
mulps %xmm3, %xmm1
shufps $0xe1, %xmm3, %xmm3     # xmm3 = xmm3[1,0,2,3]
mulps %xmm0, %xmm3
addps %xmm3, %xmm1
movaps %xmm1, %xmm2
mulps %xmm1, %xmm2
divps %xmm4, %xmm2
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0     # xmm0 = xmm0[1,1],xmm2[1,1]
addss %xmm2, %xmm0
movss 0x8556(%rip), %xmm2     # 0xe070
ucomiss %xmm0, %xmm2
jbe 0x5b2d
subss 0x98(%r14), %xmm2
ucomiss %xmm2, %xmm0
jae 0x5b31
xorl %eax, %eax
jmp 0x5b5e
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
callq 0x3240
movss 0xa0(%r14), %xmm1
movss 0x9c(%r14), %xmm2
cmpleps %xmm0, %xmm2
cmpleps %xmm1, %xmm0
andps %xmm2, %xmm0
movd %xmm0, %eax
testq %rbx, %rbx
je 0x5b72
movl %eax, %ecx
andb $0x1, %cl
cmpb %cl, 0x94(%r14)
sete (%rbx)
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Displace::act(Obj*)
void Displace::act(Obj* p) {
	if(tlim.first < TimeNow && TimeNow < tlim.second) {
		switch(motor_type) {
			case Type::incre:
				p->displace(motor(TimeNow - tlim.first));
				break;
			case Type::relpos:
				state2 = motor(TimeNow - tlim.first);
				p->displace(state2 - state1);
				state1 = state2;
				break;
			case Type::abspos:
				p->place(motor(TimeNow - tlim.first));
		}
	}
}

// Assembly:
movss 0x8(%rdi), %xmm1
movss 0xe59d(%rip), %xmm0     # 0x141dc
ucomiss %xmm1, %xmm0
jbe 0x5cf1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x5cea
movq %rsi, %rbx
movl 0x30(%r14), %eax
cmpl $0x2, %eax
je 0x5ccb
cmpl $0x1, %eax
je 0x5c93
testl %eax, %eax
jne 0x5cea
addq $0x10, %r14
subss %xmm1, %xmm0
movq %r14, %rdi
callq 0x6806
movq %rsp, %rsi
movlps %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
jmp 0x5cea
leaq 0x10(%r14), %rdi
subss %xmm1, %xmm0
callq 0x6806
movlps %xmm0, 0x3c(%r14)
movsd 0x34(%r14), %xmm1
subps %xmm1, %xmm0
movq %rsp, %rsi
movlps %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movsd 0x3c(%r14), %xmm0
movsd %xmm0, 0x34(%r14)
jmp 0x5cea
addq $0x10, %r14
subss %xmm1, %xmm0
movq %r14, %rdi
callq 0x6806
movq %rsp, %rsi
movlps %xmm0, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Rotate::act(Obj*)
void Rotate::act(Obj* p) {
	if(tlim.first < TimeNow && TimeNow < tlim.second) {
		if(motor_type == Type::incre) p->rotate(motor(TimeNow - tlim.first));
		else if(motor_type == Type::relpos) {
			state2 = motor(TimeNow - tlim.first);
			p->rotate(state2 - state1);
			state1 = state2;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss 0x8(%rdi), %xmm1
movss 0xe3e7(%rip), %xmm0     # 0x141dc
ucomiss %xmm1, %xmm0
jbe 0x5e68
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x5e68
movq %rsi, %rbx
movl 0x30(%r14), %eax
cmpl $0x1, %eax
je 0x5e3a
testl %eax, %eax
jne 0x5e68
addq $0x10, %r14
subss %xmm1, %xmm0
movq %r14, %rdi
callq 0x68b6
movq (%rbx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x10(%r14), %rdi
subss %xmm1, %xmm0
callq 0x68b6
movss %xmm0, 0x38(%r14)
subss 0x34(%r14), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movss 0x38(%r14), %xmm0
movss %xmm0, 0x34(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/ascii-anim.cpp
// Function: Scale::act(Obj*)
void Scale::act(Obj* p) {
	if(tlim.first < TimeNow && TimeNow < tlim.second) {
		if(motor_type == Type::incre) p->scale(motor(TimeNow - tlim.first));
		else {
			state2 = motor(TimeNow - tlim.first);
			p->scale(state2 / state1);
			state1 = state2;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movss 0x8(%rdi), %xmm1
movss 0xe29f(%rip), %xmm0     # 0x141dc
ucomiss %xmm1, %xmm0
jbe 0x5f83
movq %rdi, %rbx
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x5f83
movq %rsi, %r14
movl 0x30(%rbx), %ebp
leaq 0x10(%rbx), %rdi
subss %xmm1, %xmm0
callq 0x68b6
testl %ebp, %ebp
je 0x5f88
movss %xmm0, 0x38(%rbx)
divss 0x34(%rbx), %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0x58(%rax)
movss 0x38(%rbx), %xmm0
movss %xmm0, 0x34(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rax
movq 0x58(%rax), %rax
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/./ascii-anim.h
// Function: union_pt(std::pair<float, float>&, std::pair<float, float>&, std::pair<float, float> const&, std::pair<float, float> const&)
inline void union_pt(Fpair& lower1, Fpair& upper1, const Fpair& lower2, const Fpair& upper2) {
	if(lower2.first < lower1.first) lower1.first = lower2.first;
	if(lower2.second < lower1.second) lower1.second = lower2.second;
	if(upper1.first < upper2.first) upper1.first = upper2.first;
	if(upper1.second < upper2.second) upper1.second = upper2.second;
}

// Assembly:
movss (%rdx), %xmm0
movss (%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x62c0
movss %xmm0, (%rdi)
movss 0x4(%rdx), %xmm0
movss 0x4(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x62d4
movss %xmm0, 0x4(%rdi)
movss (%rcx), %xmm0
ucomiss (%rsi), %xmm0
jbe 0x62e1
movss %xmm0, (%rsi)
movss 0x4(%rcx), %xmm0
ucomiss 0x4(%rsi), %xmm0
jbe 0x62f1
movss %xmm0, 0x4(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/changliu00[P]ascii-animation/./ascii-anim.h
// Function: intersect_pt(std::pair<float, float>&, std::pair<float, float>&, std::pair<float, float> const&, std::pair<float, float> const&)
inline void intersect_pt(Fpair& lower1, Fpair& upper1, const Fpair& lower2, const Fpair& upper2) {
	if(lower1.first < lower2.first) lower1.first = lower2.first;
	if(lower1.second < lower2.second) lower1.second = lower2.second;
	if(upper2.first < upper1.first) upper1.first = upper2.first;
	if(upper2.second < upper1.second) upper1.second = upper2.second;
}

// Assembly:
movss (%rdx), %xmm0
ucomiss (%rdi), %xmm0
jbe 0x63f7
movss %xmm0, (%rdi)
movss 0x4(%rdx), %xmm0
ucomiss 0x4(%rdi), %xmm0
jbe 0x6407
movss %xmm0, 0x4(%rdi)
movss (%rcx), %xmm0
movss (%rsi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x6418
movss %xmm0, (%rsi)
movss 0x4(%rcx), %xmm0
movss 0x4(%rsi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x642c
movss %xmm0, 0x4(%rsi)
retq
nop