LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x727a
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movq (%rsi), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rsi
movl (%rsi), %edi
cmpl $0x1, %edi
je 0x71e0
cmpl $0x2, %edi
jne 0x7229
cmpl $0x13, 0x8(%rsi)
jne 0x71db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x674b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67ab
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %edi
jne 0x7229
incq %rax
leaq (%rax,%rax,2), %rdi
cmpl $0x2, (%rcx,%rdi,8)
jne 0x7239
leaq (%rcx,%rdi,8), %rdi
cmpl $0x13, 0x8(%rdi)
jne 0x7239
movq %rax, (%rbx)
movq 0x8(%rsi), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7299
movl $0xc, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %rax, %rcx
jmp 0x726b
movl 0x8(%rsi), %esi
incq %rax
movq %rax, (%rbx)
movl $0xf, %edi
jmp 0x7267
cmpl $0x2, 0x18(%rsi)
jne 0x725a
cmpl $0x15, 0x20(%rsi)
jne 0x725a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7391
movq %rax, (%rbx)
movq 0x8(%rcx,%rdx,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6249
leaq 0x21f5(%rip), %rdi      # 0x9476
leaq 0x2cbd(%rip), %rsi      # 0x9f45
leaq 0x2f1c(%rip), %rcx      # 0xa1ab
movl $0x184, %edx            # imm = 0x184
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7372
movq %rsi, %rbx
movq %rdi, %r14
callq 0x674b
movq (%r14), %rax
movq (%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x2, (%rax,%rcx,8)
jne 0x72da
leaq (%rax,%rcx,8), %rax
cmpl $0x14, 0x8(%rax)
jne 0x72da
xorl %r12d, %r12d
jmp 0x735b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movl $0x5, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
cmpl $0x2, (%rcx,%rdx,8)
jne 0x7358
leaq (%rcx,%rdx,8), %rcx
cmpl $0x18, 0x8(%rcx)
jne 0x7358
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movl $0x5, %edi
xorl %esi, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r12
movq %rax, 0x10(%r15)
movq %r15, 0x20(%rax)
movq (%r14), %rcx
movq (%rbx), %rax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rcx
cmpl $0x2, (%rcx)
movq %r12, %r15
je 0x730d
jmp 0x735b
movq %r15, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67ab
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20fd(%rip), %rdi      # 0x9476
leaq 0x2bc5(%rip), %rsi      # 0x9f45
leaq 0x2e9f(%rip), %rcx      # 0xa226
movl $0x1c3, %edx            # imm = 0x1C3
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x740c
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movl $0x4, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6249
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6de0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2a
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6e40
movl $0x3, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6249
leaq 0x2063(%rip), %rdi      # 0x9476
leaq 0x2b2b(%rip), %rsi      # 0x9f45
leaq 0x2db9(%rip), %rcx      # 0xa1da
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7471
testq %rsi, %rsi
je 0x7490
movq %rdi, %rbx
leaq 0x14b3(%rip), %rax      # 0x88fa
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2130
testq %rax, %rax
je 0x74af
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x74ce
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
leaq 0x17e2(%rip), %rdi      # 0x8c5a
leaq 0x2fd1(%rip), %rsi      # 0xa450
leaq 0x2fe3(%rip), %rcx      # 0xa469
movl $0x9, %edx
callq 0x20b0
leaq 0x2ff9(%rip), %rdi      # 0xa490
leaq 0x2fb2(%rip), %rsi      # 0xa450
leaq 0x2fc4(%rip), %rcx      # 0xa469
movl $0xa, %edx
callq 0x20b0
leaq 0x144a(%rip), %rdi      # 0x8900
leaq 0x2f93(%rip), %rsi      # 0xa450
leaq 0x2fa5(%rip), %rcx      # 0xa469
movl $0xd, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rsi, %rsi
je 0x75c3
movq %rdi, %r14
testq %rdi, %rdi
je 0x7523
movq %rsi, %rbx
movl (%r14), %edx
leaq 0x2fcc(%rip), %rsi      # 0xa4c3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movl (%r14), %eax
cmpl $0x4, %eax
je 0x752c
cmpl $0xf, %eax
movl 0x8(%r14), %edx
leaq 0x2fb2(%rip), %rsi      # 0xa4c9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
jmp 0x7541
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
leaq 0x2f96(%rip), %rsi      # 0xa4cd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
leaq 0x2f89(%rip), %r15      # 0xa4d1
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x21f0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x74ce
leaq 0x2f64(%rip), %r12      # 0xa4d4
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x21f0
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x21f0
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x74ce
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
leaq 0x1336(%rip), %rdi      # 0x8900
leaq 0x2e7f(%rip), %rsi      # 0xa450
leaq 0x2ebf(%rip), %rcx      # 0xa497
movl $0x16, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7629
callq 0x52ac
movq %rax, %rbx
callq 0x61c8
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x630b
movq %rax, (%r14)
addq $0x5, (%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7648
movq (%r14), %rdi
callq 0x77da
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x12d0(%rip), %rdi      # 0x8900
leaq 0x2e19(%rip), %rsi      # 0xa450
leaq 0x2e99(%rip), %rcx      # 0xa4d7
movl $0x38, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7836
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x77fd
cmpq $0x0, 0x20(%rbx)
je 0x7812
testq %rdi, %rdi
je 0x7802
callq 0x77da
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x77e3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpq %rbx, 0x18(%rax)
setne %cl
movq $0x0, 0x18(%rax,%rcx,8)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2140
leaq 0x272f(%rip), %rdi      # 0x9f6c
leaq 0x2c0c(%rip), %rsi      # 0xa450
leaq 0x2d00(%rip), %rcx      # 0xa54b
movl $0x85, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x78, %edi
callq 0x31c0
movq %rax, %r15
movq %rax, %rbx
leaq 0x1108b(%rip), %rax     # 0x146e0
movq %rax, (%r15)
leaq 0x8(%r15), %r12
leaq 0x18(%r15), %rbp
movq %rbp, 0x8(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x7fb2
movups 0x28(%r14), %xmm0
movups 0x38(%r14), %xmm1
movups %xmm1, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x48(%r15), %r13
leaq 0x48(%r14), %rsi
movq %r13, %rdi
callq 0x7d44
addq $0x60, %r15
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x7dc4
movq 0x50(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x36e0
xorl %r12d, %r12d
movq (%r13), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r13), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x36b6
movq 0x68(%r14), %rax
cmpq 0x60(%r14), %rax
je 0x3715
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x36ed
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x3744
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
jmp 0x3744
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x375e
movq (%rbp), %rsi
incq %rsi
callq 0x31d0
jmp 0x375e
movq %rax, %r14
movl $0x78, %esi
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movss 0x114af(%rip), %xmm0    # 0x151d4
ucomiss 0x40(%rdi), %xmm0
jb 0x3d9c
movq %rdi, %r15
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3d9c
movq %rsi, %r14
movss (%rsi), %xmm0
ucomiss 0x30(%r15), %xmm0
jb 0x3d9c
movss 0x4(%r14), %xmm1
ucomiss 0x34(%r15), %xmm1
jb 0x3d9c
movss 0x38(%r15), %xmm2
ucomiss %xmm0, %xmm2
jb 0x3d9c
movss 0x3c(%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x3d9c
movq %rdx, %rbx
movq 0x50(%r15), %rbp
movq 0x48(%r15), %r13
cmpq %r13, %rbp
je 0x3d9c
movq %rbp, %r12
addq $-0x8, %rbp
movq -0x8(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x3d70
movb $0x1, %al
cmpq %r13, %r12
jne 0x3d9e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1141a(%rip), %xmm0    # 0x151d4
jbe 0x3e87
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %r15
cmpq %r15, %r14
je 0x3dea
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r14
jmp 0x3dd3
movss 0x113de(%rip), %xmm0    # 0x151d0
movss %xmm0, 0x30(%rbx)
movl $0x3f800000, 0x34(%rbx) # imm = 0x3F800000
xorps 0xc20b(%rip), %xmm0     # 0x10010
movss %xmm0, 0x38(%rbx)
movl $0xbf800000, 0x3c(%rbx) # imm = 0xBF800000
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
je 0x3e7c
movq (%r15), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movss 0x30(%r14), %xmm0
movss 0x30(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3e3f
movss %xmm0, 0x30(%rbx)
movss 0x34(%r14), %xmm0
movss 0x34(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3e54
movss %xmm0, 0x34(%rbx)
movss 0x38(%r14), %xmm0
ucomiss 0x38(%rbx), %xmm0
jbe 0x3e65
movss %xmm0, 0x38(%rbx)
movss 0x3c(%r14), %xmm0
ucomiss 0x3c(%rbx), %xmm0
jbe 0x3e76
movss %xmm0, 0x3c(%rbx)
addq $0x8, %r15
jmp 0x3e19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x80, %edi
callq 0x31c0
movq %rax, %r15
movq %rax, %rbx
leaq 0x105c1(%rip), %rax     # 0x146e0
movq %rax, (%r15)
leaq 0x8(%r15), %r12
leaq 0x18(%r15), %rbp
movq %rbp, 0x8(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x7fb2
movups 0x28(%r14), %xmm0
movups 0x38(%r14), %xmm1
movups %xmm1, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x48(%r15), %r13
leaq 0x48(%r14), %rsi
movq %r13, %rdi
callq 0x7d44
addq $0x60, %r15
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x7dc4
leaq 0x105d6(%rip), %rax     # 0x14750
movq %rax, (%rbx)
movb 0x78(%r14), %al
movb %al, 0x78(%rbx)
movq 0x50(%r14), %rax
cmpq 0x48(%r14), %rax
je 0x41bb
xorl %r12d, %r12d
movq (%r13), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r13), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x4191
movq 0x68(%r14), %rax
cmpq 0x60(%r14), %rax
je 0x41f0
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x41c8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x421f
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
jmp 0x421f
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x4239
movq (%rbp), %rsi
incq %rsi
callq 0x31d0
jmp 0x4239
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10f6f(%rip), %xmm0    # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x42da
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x42da
movq %rsi, %r15
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%r14), %xmm0
jb 0x42da
movss 0x4(%r15), %xmm1
ucomiss 0x34(%r14), %xmm1
jb 0x42da
movss 0x38(%r14), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x42da
movss 0x3c(%r14), %xmm0
ucomiss %xmm1, %xmm0
jb 0x42da
movq 0x50(%r14), %r13
movq %r13, %r12
cmpq 0x48(%r14), %r13
je 0x42d3
leaq -0x8(%r12), %r13
movq -0x8(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
xorl %edx, %edx
callq *0x20(%rax)
testb %al, %al
jne 0x42b1
cmpq 0x48(%r14), %r12
sete %al
testq %rbx, %rbx
je 0x42e6
cmpb %al, 0x78(%r14)
sete (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10ed8(%rip), %xmm0    # 0x151d4
jbe 0x43cc
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %r15
cmpq %r15, %r14
je 0x432c
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
addq $0x8, %r14
jmp 0x4315
movss 0x10e9c(%rip), %xmm0    # 0x151d0
movaps 0xbcd5(%rip), %xmm1     # 0x10010
xorps %xmm0, %xmm1
movss %xmm1, 0x30(%rbx)
movl $0xbf800000, 0x34(%rbx) # imm = 0xBF800000
movss %xmm0, 0x38(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
je 0x43c1
movq (%r15), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movss 0x30(%r14), %xmm0
ucomiss 0x30(%rbx), %xmm0
jbe 0x4380
movss %xmm0, 0x30(%rbx)
movss 0x34(%r14), %xmm0
ucomiss 0x34(%rbx), %xmm0
jbe 0x4391
movss %xmm0, 0x34(%rbx)
movss 0x38(%r14), %xmm0
movss 0x38(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x43a6
movss %xmm0, 0x38(%rbx)
movss 0x3c(%r14), %xmm0
movss 0x3c(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x43bb
movss %xmm0, 0x3c(%rbx)
addq $0x8, %r15
jmp 0x435e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rsp), %r14
leaq 0x9(%rsp), %r15
movss 0x78(%rbx), %xmm0
addss 0x10ae2(%rip), %xmm0    # 0x151d4
movss %xmm0, 0x10ada(%rip)    # 0x151d4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x0, 0x10ac2(%rip)     # 0x151cc
jle 0x4835
xorl %eax, %eax
movss 0xb916(%rip), %xmm0     # 0x10030
movss %xmm0, 0xc(%rsp)
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x10a9d(%rip)     # 0x151c8
jle 0x47e8
movss 0x10a97(%rip), %xmm0    # 0x151d0
xorps 0xb8d0(%rip), %xmm0     # 0x10010
movaps %xmm0, 0x20(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %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 %r14, %rsi
movq %r15, %rdx
callq *0x20(%rax)
testb %al, %al
jne 0x478f
movb $0x0, 0x9(%rsp)
movzbl 0x9(%rsp), %eax
movl %ebp, %ecx
shll %cl, %eax
xorl %eax, %r12d
incl %ebp
cmpl $0x3, %ebp
jne 0x474d
movslq %r12d, %rax
leaq 0xb8df(%rip), %rcx      # 0x1008b
movb (%rax,%rcx), %al
movb %al, 0xb(%rsp)
movl $0x1, %edx
movq 0x107f9(%rip), %rdi     # 0x14fb8
leaq 0xb(%rsp), %rsi
callq 0x3210
movaps 0x20(%rsp), %xmm0
addss 0x7c(%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
incl %r13d
cmpl 0x109e6(%rip), %r13d    # 0x151c8
jl 0x4748
movb $0xa, 0xa(%rsp)
movl $0x1, %edx
movq 0x107bf(%rip), %rdi     # 0x14fb8
leaq 0xa(%rsp), %rsi
callq 0x3210
movss 0x80(%rbx), %xmm0
mulss 0xb821(%rip), %xmm0     # 0x10034
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movl 0x14(%rsp), %eax
incl %eax
cmpl 0x1099d(%rip), %eax     # 0x151cc
jl 0x4720
movss 0x78(%rbx), %xmm0
mulss 0xb7f6(%rip), %xmm0     # 0x10038
cvttss2si %xmm0, %rdi
callq 0x3250
movq 0x88(%rbx), %rsi
movq 0x90(%rbx), %rdx
movq 0x10757(%rip), %rdi     # 0x14fb8
callq 0x3210
movss 0x10(%rsp), %xmm0
ucomiss 0x10961(%rip), %xmm0    # 0x151d4
ja 0x46e5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10778(%rip), %xmm0    # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x4aab
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4aab
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 0x4abe
movl %eax, %ecx
andb $0x1, %cl
cmpb %cl, 0x8c(%rdi)
sete (%rdx)
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rsi, %r14
movss %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movss 0x28(%rdi), %xmm1
subss (%rsi), %xmm1
movss %xmm1, 0xc(%rsp)
movss 0x2c(%rdi), %xmm1
subss 0x4(%rsi), %xmm1
movss %xmm1, 0x14(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x3320
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x3050
xorps %xmm1, %xmm1
cvtsd2ss 0x20(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movss 0x14(%rsp), %xmm3
movaps %xmm3, %xmm2
mulss %xmm0, %xmm2
mulss %xmm1, %xmm3
movss 0xc(%rsp), %xmm4
mulss %xmm4, %xmm1
subss %xmm2, %xmm1
mulss %xmm0, %xmm4
addss %xmm4, %xmm3
addss (%r14), %xmm1
addss 0x4(%r14), %xmm3
movss %xmm1, 0x28(%rbx)
movss %xmm3, 0x2c(%rbx)
movss 0x10(%rsp), %xmm0
addss 0x78(%rbx), %xmm0
movss %xmm0, 0x78(%rbx)
movss 0x84(%rbx), %xmm2
movss 0x88(%rbx), %xmm1
mulss 0x4(%r14), %xmm1
mulss (%r14), %xmm2
addss %xmm1, %xmm2
subss 0x7c(%rbx), %xmm2
movss %xmm2, 0x10(%rsp)
callq 0x3150
movss %xmm0, 0xc(%rsp)
movss 0x78(%rbx), %xmm0
callq 0x3180
movss 0xc(%rsp), %xmm1
movss %xmm1, 0x84(%rbx)
movss %xmm0, 0x88(%rbx)
mulss 0x4(%r14), %xmm0
mulss (%r14), %xmm1
addss %xmm0, %xmm1
subss 0x10(%rsp), %xmm1
movss %xmm1, 0x7c(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movss 0x28(%rdi), %xmm1
mulss %xmm0, %xmm1
movss 0x2c(%rdi), %xmm2
mulss %xmm0, %xmm2
movss 0xb3a7(%rip), %xmm3     # 0x10030
subss %xmm0, %xmm3
movss (%rsi), %xmm4
mulss %xmm3, %xmm4
addss %xmm1, %xmm4
movss 0x4(%rsi), %xmm1
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
movss %xmm4, 0x28(%rdi)
movss %xmm1, 0x2c(%rdi)
movss 0x84(%rdi), %xmm1
movss 0x88(%rdi), %xmm2
mulss 0x4(%rsi), %xmm2
mulss (%rsi), %xmm1
addss %xmm2, %xmm1
movss 0x7c(%rdi), %xmm2
mulss %xmm0, %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0x7c(%rdi)
mulss 0x80(%rdi), %xmm0
movss %xmm0, 0x80(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb331(%rip), %xmm1     # 0x10030
subss %xmm0, %xmm1
mulss 0xb331(%rip), %xmm1     # 0x1003c
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_O1/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 0x10014(%rip), %xmm0    # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x527a
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x527a
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%rdi), %xmm0
jb 0x527a
movss 0x4(%rsi), %xmm1
ucomiss 0x34(%rdi), %xmm1
jb 0x527a
movss 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x527a
movss 0x3c(%rdi), %xmm2
ucomiss %xmm1, %xmm2
jb 0x527a
subss 0x78(%rdi), %xmm0
subss 0x7c(%rdi), %xmm1
movss 0x94(%rdi), %xmm3
mulss %xmm0, %xmm3
movss 0x90(%rdi), %xmm2
mulss %xmm1, %xmm2
subss %xmm3, %xmm2
movss 0xa0(%rdi), %xmm3
divss %xmm3, %xmm2
xorl %eax, %eax
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm2
jb 0x527a
mulss 0x98(%rdi), %xmm1
mulss 0x9c(%rdi), %xmm0
subss %xmm1, %xmm0
divss %xmm3, %xmm0
ucomiss %xmm4, %xmm0
jb 0x527a
addss %xmm0, %xmm2
movss 0xadbc(%rip), %xmm0     # 0x10030
ucomiss %xmm2, %xmm0
setae %al
testq %rdx, %rdx
je 0x5288
cmpb %al, 0xa4(%rdi)
sete (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x88(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x30(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3320
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3050
cvtsd2ss 0x10(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0xac18(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
movss (%rcx), %xmm3
movss 0x4(%rcx), %xmm4
movss (%r14), %xmm5
movss 0x4(%r14), %xmm6
subss %xmm5, %xmm3
subss %xmm6, %xmm4
movaps %xmm1, %xmm7
mulss %xmm4, %xmm7
mulss %xmm2, %xmm4
movaps %xmm1, %xmm8
mulss %xmm3, %xmm8
addss %xmm4, %xmm8
mulss %xmm0, %xmm3
addss %xmm7, %xmm3
addss %xmm5, %xmm8
addss %xmm6, %xmm3
movss %xmm8, (%rcx)
movss %xmm3, 0x4(%rcx)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x53fd
movss 0x80(%rbx), %xmm0
movss 0x78(%rbx), %xmm1
movss 0x7c(%rbx), %xmm2
subss %xmm1, %xmm0
movss 0x84(%rbx), %xmm3
subss %xmm2, %xmm3
movss %xmm0, 0x90(%rbx)
movss %xmm3, 0x94(%rbx)
movss 0x88(%rbx), %xmm0
subss %xmm1, %xmm0
movss 0x8c(%rbx), %xmm1
subss %xmm2, %xmm1
movss %xmm0, 0x98(%rbx)
movss %xmm1, 0x9c(%rbx)
movq %rbx, %rdi
callq 0x4d2e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
leaq 0x78(%rdi), %rcx
movq %rcx, -0x30(%rsp)
leaq 0x80(%rdi), %rcx
movq %rcx, -0x28(%rsp)
leaq 0x88(%rdi), %rcx
movq %rcx, -0x20(%rsp)
leaq 0x28(%rdi), %rcx
movq %rcx, -0x18(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x38(%rdi), %rcx
movq %rcx, -0x8(%rsp)
movss 0xab1f(%rip), %xmm1     # 0x10030
subss %xmm0, %xmm1
movss (%rsi), %xmm2
mulss %xmm1, %xmm2
mulss 0x4(%rsi), %xmm1
xorl %ecx, %ecx
movq -0x30(%rsp,%rcx), %rdx
movss (%rdx), %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movss 0x4(%rdx), %xmm4
mulss %xmm0, %xmm4
addss %xmm1, %xmm4
movss %xmm3, (%rdx)
movss %xmm4, 0x4(%rdx)
addq $0x8, %rcx
cmpq $0x30, %rcx
jne 0x5524
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x556d
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rdx
movq %rdx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movss 0x90(%rax), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x90(%rax)
movss 0x94(%rax), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x94(%rax)
movss 0x98(%rax), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x98(%rax)
movss 0x9c(%rax), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x9c(%rax)
mulss %xmm0, %xmm0
mulss 0xa0(%rax), %xmm0
movss %xmm0, 0xa0(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf45e(%rip), %xmm0     # 0x151d4
xorl %r15d, %r15d
ucomiss 0x40(%rdi), %xmm0
jb 0x5dee
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x5dee
movq %rsi, %r12
movss (%rsi), %xmm0
xorl %r15d, %r15d
ucomiss 0x30(%r14), %xmm0
jb 0x5dee
movss 0x4(%r12), %xmm1
ucomiss 0x34(%r14), %xmm1
jb 0x5dee
movss 0x38(%r14), %xmm2
xorl %r15d, %r15d
ucomiss %xmm0, %xmm2
jb 0x5dee
movss 0x3c(%r14), %xmm0
ucomiss %xmm1, %xmm0
jb 0x5dee
leaq 0x98(%r14), %rdi
xorl %r15d, %r15d
movq %r12, %rsi
xorl %edx, %edx
callq 0x4a54
testb %al, %al
je 0x5dee
leaq 0x128(%r14), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4a54
movl %eax, %r15d
testq %rbx, %rbx
je 0x5dfd
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_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x20(%rsp)
movss %xmm0, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3320
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3050
cvtsd2ss 0x10(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0xa050(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
movss (%rcx), %xmm3
movss 0x4(%rcx), %xmm4
movss (%r14), %xmm5
movss 0x4(%r14), %xmm6
subss %xmm5, %xmm3
subss %xmm6, %xmm4
movaps %xmm1, %xmm7
mulss %xmm4, %xmm7
mulss %xmm2, %xmm4
movaps %xmm1, %xmm8
mulss %xmm3, %xmm8
addss %xmm4, %xmm8
mulss %xmm0, %xmm3
addss %xmm7, %xmm3
addss %xmm5, %xmm8
addss %xmm6, %xmm3
movss %xmm8, (%rcx)
movss %xmm3, 0x4(%rcx)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x5fc5
leaq 0x98(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x4b46
leaq 0x128(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x4b46
movss 0x4(%rsp), %xmm0
addss 0x90(%rbx), %xmm0
movss %xmm0, 0x90(%rbx)
callq 0x3150
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 0x589a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rdi), %rax
movq %rax, 0x20(%rsp)
movss 0x9f51(%rip), %xmm4     # 0x10030
subss %xmm0, %xmm4
movss (%rsi), %xmm1
mulss %xmm4, %xmm1
mulss 0x4(%rsi), %xmm4
xorl %eax, %eax
movq 0x8(%rsp,%rax), %rcx
movss (%rcx), %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movss 0x4(%rcx), %xmm3
mulss %xmm0, %xmm3
addss %xmm4, %xmm3
movss %xmm2, (%rcx)
movss %xmm3, 0x4(%rcx)
addq $0x8, %rax
cmpq $0x20, %rax
jne 0x60f2
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x613b
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movss 0x88(%rbx), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x88(%rbx)
movss 0x8c(%rbx), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x8c(%rbx)
leaq 0x98(%rbx), %rdi
movq %r14, %rsi
movss %xmm0, 0x4(%rsp)
callq 0x4c6c
leaq 0x128(%rbx), %rdi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
callq 0x4c6c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61de
sqrtss %xmm0, %xmm0
jmp 0x61e6
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 0x623f
sqrtss %xmm0, %xmm0
jmp 0x6244
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_O1/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 0xec90(%rip), %xmm0     # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x6616
movss 0x44(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x6616
movss (%rsi), %xmm0
xorl %eax, %eax
ucomiss 0x30(%rdi), %xmm0
jb 0x6616
movss 0x4(%rsi), %xmm1
ucomiss 0x34(%rdi), %xmm1
jb 0x6616
movss 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomiss %xmm0, %xmm2
jb 0x6616
movss 0x3c(%rdi), %xmm2
ucomiss %xmm1, %xmm2
jb 0x6616
subss 0x78(%rdi), %xmm0
subss 0x7c(%rdi), %xmm1
movss 0x80(%rdi), %xmm2
movss 0x84(%rdi), %xmm3
movaps %xmm1, %xmm4
mulss %xmm3, %xmm4
movaps %xmm0, %xmm5
mulss %xmm2, %xmm5
addss %xmm4, %xmm5
xorps %xmm4, %xmm4
cvtss2sd %xmm5, %xmm4
xorps %xmm5, %xmm5
cvtss2sd 0x88(%rdi), %xmm5
mulsd %xmm4, %xmm4
divsd %xmm5, %xmm4
mulss %xmm2, %xmm1
mulss %xmm3, %xmm0
subss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x8c(%rdi), %xmm1
mulsd %xmm0, %xmm0
divsd %xmm1, %xmm0
addsd %xmm4, %xmm0
movsd 0x9a51(%rip), %xmm1     # 0x10060
ucomisd %xmm0, %xmm1
seta %al
testq %rdx, %rdx
je 0x6624
cmpb %al, 0x94(%rdi)
sete (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rdi), %rax
movq %rax, 0x20(%rsp)
movss %xmm0, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x3320
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3050
cvtsd2ss 0x10(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
movaps 0x98e0(%rip), %xmm2     # 0x10010
xorps %xmm0, %xmm2
xorl %eax, %eax
movq 0x18(%rsp,%rax), %rcx
movss (%rcx), %xmm3
movss 0x4(%rcx), %xmm4
movss (%r14), %xmm5
movss 0x4(%r14), %xmm6
subss %xmm5, %xmm3
subss %xmm6, %xmm4
movaps %xmm1, %xmm7
mulss %xmm4, %xmm7
mulss %xmm2, %xmm4
movaps %xmm1, %xmm8
mulss %xmm3, %xmm8
addss %xmm4, %xmm8
mulss %xmm0, %xmm3
addss %xmm7, %xmm3
addss %xmm5, %xmm8
addss %xmm6, %xmm3
movss %xmm8, (%rcx)
movss %xmm3, 0x4(%rcx)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x6735
movss 0x4(%rsp), %xmm0
addss 0x90(%rbx), %xmm0
movss %xmm0, 0x90(%rbx)
callq 0x3150
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 0x6198
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
movss 0x88(%rdi), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, 0x88(%rdi)
mulss 0x8c(%rdi), %xmm1
movss %xmm1, 0x8c(%rdi)
leaq 0x78(%rdi), %rcx
movq %rcx, -0x20(%rsp)
leaq 0x28(%rdi), %rcx
movq %rcx, -0x18(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x10(%rsp)
leaq 0x38(%rdi), %rcx
movq %rcx, -0x8(%rsp)
movss 0x97ea(%rip), %xmm1     # 0x10030
subss %xmm0, %xmm1
movss (%rsi), %xmm2
mulss %xmm1, %xmm2
mulss 0x4(%rsi), %xmm1
xorl %ecx, %ecx
movq -0x20(%rsp,%rcx), %rdx
movss (%rdx), %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movss 0x4(%rdx), %xmm4
mulss %xmm0, %xmm4
addss %xmm1, %xmm4
movss %xmm3, (%rdx)
movss %xmm4, 0x4(%rdx)
addq $0x8, %rcx
cmpq $0x20, %rcx
jne 0x6859
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x68a2
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rdx
movq %rdx, 0x30(%rax)
movq %rcx, 0x38(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe42e(%rip), %xmm0     # 0x151d4
xorl %eax, %eax
ucomiss 0x40(%rdi), %xmm0
jb 0x6ea7
movss 0x44(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x6ea7
movss (%rsi), %xmm2
xorl %eax, %eax
ucomiss 0x30(%r14), %xmm2
jb 0x6ea7
movss 0x4(%rsi), %xmm0
ucomiss 0x34(%r14), %xmm0
jb 0x6ea7
movss 0x38(%r14), %xmm1
xorl %eax, %eax
ucomiss %xmm2, %xmm1
jb 0x6ea7
movss 0x3c(%r14), %xmm1
ucomiss %xmm0, %xmm1
jb 0x6ea7
subss 0x78(%r14), %xmm2
subss 0x7c(%r14), %xmm0
movss 0x80(%r14), %xmm3
movss 0x84(%r14), %xmm4
movaps %xmm0, %xmm5
mulss %xmm4, %xmm5
movaps %xmm2, %xmm1
mulss %xmm3, %xmm1
addss %xmm5, %xmm1
mulss %xmm3, %xmm0
mulss %xmm4, %xmm2
subss %xmm2, %xmm0
movaps %xmm1, %xmm3
mulss %xmm1, %xmm3
divss 0x88(%r14), %xmm3
movaps %xmm0, %xmm2
mulss %xmm0, %xmm2
divss 0x8c(%r14), %xmm2
addss %xmm3, %xmm2
movss 0x91c6(%rip), %xmm3     # 0x10030
ucomiss %xmm2, %xmm3
jbe 0x6e7d
subss 0x98(%r14), %xmm3
ucomiss %xmm3, %xmm2
jae 0x6e81
xorl %eax, %eax
jmp 0x6ea7
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 0x6ebb
movl %eax, %ecx
andb $0x1, %cl
cmpb %cl, 0x94(%r14)
sete (%rbx)
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss 0x8(%rdi), %xmm1
movss 0xe1de(%rip), %xmm0     # 0x151d4
ucomiss %xmm1, %xmm0
jbe 0x7103
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x7103
movq %rsi, %rbx
movl 0x30(%r14), %eax
cmpl $0x2, %eax
je 0x70d0
cmpl $0x1, %eax
je 0x7069
testl %eax, %eax
jne 0x7103
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x710d
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq *0x28(%r14)
movlps %xmm0, (%r15)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x30(%rax)
jmp 0x7103
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x710d
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq *0x28(%r14)
movss %xmm0, 0x3c(%r14)
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movss %xmm1, 0x40(%r14)
movss 0x34(%r14), %xmm2
subss 0x38(%r14), %xmm1
subss %xmm2, %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, (%r15)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x30(%rax)
movq 0x3c(%r14), %rax
movq %rax, 0x34(%r14)
jmp 0x7103
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x710d
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq *0x28(%r14)
movlps %xmm0, (%r15)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x38(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x30a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdf5b(%rip), %xmm0     # 0x151d4
ucomiss %xmm1, %xmm0
jbe 0x7304
movq %rdi, %r14
movss 0xc(%rdi), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x7304
movq %rsi, %rbx
movl 0x30(%r14), %eax
cmpl $0x1, %eax
je 0x72c5
testl %eax, %eax
jne 0x7304
subss %xmm1, %xmm0
movss %xmm0, (%rsp)
cmpq $0x0, 0x20(%r14)
je 0x730c
leaq 0x10(%r14), %rdi
movq %rsp, %rsi
callq *0x28(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
jmp 0x7304
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
cmpq $0x0, 0x20(%r14)
je 0x730c
leaq 0x10(%r14), %rdi
leaq 0x4(%rsp), %rsi
callq *0x28(%r14)
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
callq 0x30a0
nop