LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TasnimAnas[P]Attendance-Management-System/src/LoginDetails.cpp
// Function: isRightPassword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isRightPassword(string Password)
{
    string mypassword = "323443443487279223215223231";
    Password = encript(Password);
    if (mypassword == Password)
    {
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3470
movq -0x98(%rbp), %rdx
leaq 0xa59b(%rip), %rsi      # 0xe00f
leaq -0x30(%rbp), %rdi
callq 0x3cf0
jmp 0x3a7f
leaq -0x31(%rbp), %rdi
callq 0x32c0
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3100
jmp 0x3a9d
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3b70
jmp 0x3aaf
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3330
leaq -0x68(%rbp), %rdi
callq 0x3180
leaq -0x88(%rbp), %rdi
callq 0x3180
movq -0xa0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3da0
testb $0x1, %al
jne 0x3aea
jmp 0x3b39
movb $0x1, -0x1(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0x3b47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32c0
jmp 0x3b67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3180
jmp 0x3b5e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x40(%rbp), %rdi
callq 0x3460
// File: TasnimAnas[P]Attendance-Management-System/src/LoginDetails.cpp
// Function: encript(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string encript(string input)
{
    string password_ = "";
    for (int i = 0; i < input.size(); i++)
    {
        int chk = (int(input[i]) * 4) + 23;
        password_ = password_ + to_string(chk);
    }
    return password_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3470
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0xa8fa(%rip), %rsi      # 0xe4b2
callq 0x3cf0
jmp 0x3bbf
leaq -0x12(%rbp), %rdi
callq 0x32c0
movl $0x0, -0x28(%rbp)
movq -0x90(%rbp), %rdi
movslq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x31a0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x3cb2
movq -0x90(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3500
movq %rax, -0xa0(%rbp)
jmp 0x3c12
movq -0xa0(%rbp), %rax
movsbl (%rax), %ecx
movl %ecx, %eax
leal 0x17(,%rax,4), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x3e80
jmp 0x3c36
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x3e30
jmp 0x3c49
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3330
leaq -0x50(%rbp), %rdi
callq 0x3180
leaq -0x70(%rbp), %rdi
callq 0x3180
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3bcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x32c0
jmp 0x3cde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3cd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3180
jmp 0x3cd5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3cc5
movq -0x80(%rbp), %rdi
callq 0x3180
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3180
movq -0x20(%rbp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/ShowDetails.cpp
// Function: showHeader()
void showHeader()
{
     cout << endl
          << "      [][][][][][][][][][][][][][][][][][][][]" << endl
          << "      []            Student Details         []" << endl
          << "      [][][][][][][][][][][][][][][][][][][][]" << endl
          << endl;
     cout << "                       Details" << endl
          << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xf825(%rip), %rdi      # 0x13fd0
movq 0xf806(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x99a8(%rip), %rsi      # 0xe169
callq 0x3270
movq %rax, %rdi
movq 0xf7e8(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x99b9(%rip), %rsi      # 0xe198
callq 0x3270
movq %rax, %rdi
movq 0xf7ca(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x996c(%rip), %rsi      # 0xe169
callq 0x3270
movq %rax, %rdi
movq 0xf7ac(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xf79d(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0xf7a9(%rip), %rdi      # 0x13fd0
leaq 0x9999(%rip), %rsi      # 0xe1c7
callq 0x3270
movq %rax, %rdi
movq 0xf77b(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xf76c(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentAdd.cpp
// Function: StudentAddHeader()
void StudentAddHeader()
{
    cout << endl
         << "      +++++++++++++++++++++++++++++++++++++++" << endl
         << "      +              Add Student            +" << endl
         << "      +++++++++++++++++++++++++++++++++++++++" << endl
         << endl;
    cout << "                     Add Details" << endl
         << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xf265(%rip), %rdi      # 0x13fd0
movq 0xf246(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x94fb(%rip), %rsi      # 0xe27c
callq 0x3270
movq %rax, %rdi
movq 0xf228(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x950b(%rip), %rsi      # 0xe2aa
callq 0x3270
movq %rax, %rdi
movq 0xf20a(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x94bf(%rip), %rsi      # 0xe27c
callq 0x3270
movq %rax, %rdi
movq 0xf1ec(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xf1dd(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0xf1e9(%rip), %rdi      # 0x13fd0
leaq 0x94ea(%rip), %rsi      # 0xe2d8
callq 0x3270
movq %rax, %rdi
movq 0xf1bb(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xf1ac(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentAdd.cpp
// Function: add(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add(int roll, string name)
{
    StudentClass std;
    std.setName(name);
    std.setRoll(roll);
    ::Student.push_back(std);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5210
movq -0x98(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3100
jmp 0x4e54
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7650
jmp 0x4e63
leaq -0x80(%rbp), %rdi
callq 0x3180
movl -0x4(%rbp), %esi
leaq -0x60(%rbp), %rdi
callq 0x7610
jmp 0x4e7a
leaq 0xf42f(%rip), %rdi      # 0x142b0
leaq -0x60(%rbp), %rsi
callq 0x5290
jmp 0x4e8c
leaq -0x60(%rbp), %rdi
callq 0x5300
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x4ecd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3180
leaq -0x60(%rbp), %rdi
callq 0x5300
movq -0x88(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentAdd.cpp
// Function: SortStudentList()
void SortStudentList()
{
    for (int i = 1; i < ::Student.size(); i++)
    {
        ::StudentClass temp = ::Student[i];
        int j = i - 1;
        while (temp.getRoll() < Student[j].getRoll() && j >= 0)
        {
            Student[j + 1] = Student[j];
            j--;
        }
        Student[j + 1] = temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x1, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0xf39f(%rip), %rdi      # 0x142b0
callq 0x4860
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x5042
movslq -0x4(%rbp), %rsi
leaq 0xf37f(%rip), %rdi      # 0x142b0
callq 0x48b0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x5330
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7630
movl %eax, -0x7c(%rbp)
jmp 0x4f59
movslq -0x5c(%rbp), %rsi
leaq 0xf34c(%rip), %rdi      # 0x142b0
callq 0x48b0
movq %rax, %rdi
callq 0x7630
movl %eax, -0x80(%rbp)
jmp 0x4f76
movl -0x7c(%rbp), %ecx
movl -0x80(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x81(%rbp)
jge 0x4f95
cmpl $0x0, -0x5c(%rbp)
setge %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x4fa1
jmp 0x5009
movslq -0x5c(%rbp), %rsi
leaq 0xf304(%rip), %rdi      # 0x142b0
movq %rdi, -0x98(%rbp)
callq 0x48b0
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
movl -0x5c(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x48b0
movq -0x90(%rbp), %rsi
movq %rax, %rdi
callq 0x53a0
jmp 0x4fe4
movl -0x5c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x4f4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5300
jmp 0x504b
movl -0x5c(%rbp), %eax
incl %eax
movslq %eax, %rsi
leaq 0xf298(%rip), %rdi      # 0x142b0
callq 0x48b0
movq %rax, %rdi
leaq -0x58(%rbp), %rsi
callq 0x53a0
jmp 0x502b
leaq -0x58(%rbp), %rdi
callq 0x5300
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4f02
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentAdd.cpp
// Function: writeSorted()
void writeSorted()
{
    char filename[] = "Output/Student.txt";
    char binfilename[] = ".Data/input.bin";
    char binfileAttendance[] = ".Data/Attendance.bin";
    int garbage = remove(filename);
    garbage = remove(binfilename);
    garbage = remove(binfileAttendance);

    writeHeader();
    for (int i = 0; i < ::Student.size(); i++)
    {
        writeSl(i + 1);
        writeRoll(Student[i].getRoll());
        writeName(Student[i].getName());
        writeAttendance(i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x92ae(%rip), %rax      # 0xe320
movq %rax, -0x20(%rbp)
movq 0x92ab(%rip), %rax      # 0xe328
movq %rax, -0x18(%rbp)
movw 0x92a8(%rip), %ax       # 0xe330
movw %ax, -0x10(%rbp)
movb 0x92a0(%rip), %al       # 0xe332
movb %al, -0xe(%rbp)
movq 0x92a4(%rip), %rax      # 0xe340
movq %rax, -0x30(%rbp)
movq 0x92a1(%rip), %rax      # 0xe348
movq %rax, -0x28(%rbp)
movq 0x929e(%rip), %rax      # 0xe350
movq %rax, -0x50(%rbp)
movq 0x929b(%rip), %rax      # 0xe358
movq %rax, -0x48(%rbp)
movl 0x9299(%rip), %eax      # 0xe360
movl %eax, -0x40(%rbp)
movb 0x9294(%rip), %al       # 0xe364
movb %al, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x34a0
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34a0
movl %eax, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34a0
movl %eax, -0x54(%rbp)
callq 0x97a0
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0xf19b(%rip), %rdi      # 0x142b0
callq 0x4860
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x51c7
movl -0x58(%rbp), %edi
incl %edi
callq 0x99a0
movslq -0x58(%rbp), %rsi
leaq 0xf16e(%rip), %rdi      # 0x142b0
movq %rdi, -0xa0(%rbp)
callq 0x48b0
movq %rax, %rdi
callq 0x7630
movl %eax, %edi
callq 0x9a80
movq -0xa0(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0x48b0
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x7670
movq -0x98(%rbp), %rdi
callq 0x9bf0
jmp 0x518e
leaq -0x78(%rbp), %rdi
callq 0x3180
movl -0x58(%rbp), %edi
callq 0x9d70
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x5103
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3180
jmp 0x51d0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentClass.cpp
// Function: StudentClass::getLast7()
float StudentClass::getLast7()
{
    if (isPresent.size() < 7)
    {
        return -1;
    }
    float present = 0;
    for (int i = isPresent.size() - 7; i < isPresent.size(); i++)
    {
        if (isPresent[i] == 1)
        {
            present++;
        }
    }
    return (present / 7.0) * 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x5a50
cmpq $0x7, %rax
jae 0x7765
movss 0x6c29(%rip), %xmm0     # 0xe384
movss %xmm0, -0x4(%rbp)
jmp 0x7817
movq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
addq $0x28, %rdi
callq 0x5a50
subq $0x7, %rax
movl %eax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x5a50
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x77ed
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rsi
callq 0x7a90
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6740
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x77e0
movss 0x6baa(%rip), %xmm0     # 0xe380
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x77e2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7781
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6b72(%rip), %xmm1     # 0xe370
divsd %xmm1, %xmm0
movsd 0x6b5e(%rip), %xmm1     # 0xe368
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentClass.cpp
// Function: StudentClass::getLast30()
float StudentClass::getLast30()
{
    if (isPresent.size() < 30)
    {
        return -1;
    }
    float present = 0;
    for (int i = isPresent.size() - 30; i < isPresent.size(); i++)
    {
        if (isPresent[i] == 1)
        {
            present++;
        }
    }
    return (present / 30.0) * 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x5a50
cmpq $0x1e, %rax
jae 0x7865
movss 0x6b29(%rip), %xmm0     # 0xe384
movss %xmm0, -0x4(%rbp)
jmp 0x7917
movq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
addq $0x28, %rdi
callq 0x5a50
subq $0x1e, %rax
movl %eax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x5a50
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x78ed
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rsi
callq 0x7a90
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6740
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x78e0
movss 0x6aaa(%rip), %xmm0     # 0xe380
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x78e2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7881
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6a7a(%rip), %xmm1     # 0xe378
divsd %xmm1, %xmm0
movsd 0x6a5e(%rip), %xmm1     # 0xe368
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentClass.cpp
// Function: StudentClass::getTotalPresentDays()
int StudentClass::getTotalPresentDays()
{
    int present = 0;
    for (int i = 0; i < isPresent.size(); i++)
    {
        if (isPresent[i])
        {
            present++;
        }
    }
    return present;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x5a50
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x79b1
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x7a90
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6740
testb $0x1, %al
jne 0x799b
jmp 0x79a4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x79a6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7952
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/StudentRemove.cpp
// Function: StudentRemoveHeader()
void StudentRemoveHeader()
{
    cout << endl
         << "      -----------------------------------------" << endl
         << "      -              Remove Student           -" << endl
         << "      -----------------------------------------" << endl
         << endl;
    cout << "                     Remove Details" << endl
         << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb0e5(%rip), %rdi      # 0x13fd0
movq 0xb0c6(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x5504(%rip), %rsi      # 0xe405
callq 0x3270
movq %rax, %rdi
movq 0xb0a8(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x5516(%rip), %rsi      # 0xe435
callq 0x3270
movq %rax, %rdi
movq 0xb08a(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x54c8(%rip), %rsi      # 0xe405
callq 0x3270
movq %rax, %rdi
movq 0xb06c(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xb05d(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0xb069(%rip), %rdi      # 0x13fd0
leaq 0x54f7(%rip), %rsi      # 0xe465
callq 0x3270
movq %rax, %rdi
movq 0xb03b(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xb02c(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/WelcomePage.cpp
// Function: welcomePage()
void welcomePage()
{
    cout << "Select option (1,2): ";
    int welcomePageSelection;
    cin >> welcomePageSelection;
    if (welcomePageSelection == 1)
    {
        system("CLS");
        logInPageHeader();
        logInPage();
    }
    else if (welcomePageSelection == 2)
    {
    }
    else
    {
        system("CLS");
        welcomePageHeader();
        cout << "Invalid selection! ";
        welcomePage();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xa9b1(%rip), %rdi      # 0x13fd0
leaq 0x4e63(%rip), %rsi      # 0xe489
callq 0x3270
movq 0xa9ae(%rip), %rdi      # 0x13fe0
leaq -0x4(%rbp), %rsi
callq 0x3170
cmpl $0x1, -0x4(%rbp)
jne 0x9659
leaq 0x4bb3(%rip), %rdi      # 0xe1fb
callq 0x3230
callq 0xb150
callq 0xacf0
jmp 0x968c
cmpl $0x2, -0x4(%rbp)
jne 0x9661
jmp 0x968a
leaq 0x4b93(%rip), %rdi      # 0xe1fb
callq 0x3230
callq 0x96a0
movq 0xa957(%rip), %rdi      # 0x13fd0
leaq 0x4e1f(%rip), %rsi      # 0xe49f
callq 0x3270
callq 0x9610
jmp 0x968c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/WelcomePage.cpp
// Function: welcomePageHeader()
void welcomePageHeader()
{
    cout << endl
         << "      ****************************************" << endl
         << "      *      Welcome to EASY ATTENDANCE!     *" << endl
         << "      ****************************************" << endl
         << endl;
    cout << "                    Welcome Page" << endl
         << endl;
    cout << "1. Login" << endl;
    cout << "2. Exit" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa925(%rip), %rdi      # 0x13fd0
movq 0xa906(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x4df2(%rip), %rsi      # 0xe4b3
callq 0x3270
movq %rax, %rdi
movq 0xa8e8(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x4e03(%rip), %rsi      # 0xe4e2
callq 0x3270
movq %rax, %rdi
movq 0xa8ca(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x4db6(%rip), %rsi      # 0xe4b3
callq 0x3270
movq %rax, %rdi
movq 0xa8ac(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xa89d(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0xa8a9(%rip), %rdi      # 0x13fd0
leaq 0x4de3(%rip), %rsi      # 0xe511
callq 0x3270
movq %rax, %rdi
movq 0xa87b(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0xa86c(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0xa878(%rip), %rdi      # 0x13fd0
leaq 0x4dd3(%rip), %rsi      # 0xe532
callq 0x3270
movq %rax, %rdi
movq 0xa84a(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0xa856(%rip), %rdi      # 0x13fd0
leaq 0x4dba(%rip), %rsi      # 0xe53b
callq 0x3270
movq %rax, %rdi
movq 0xa828(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw (%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/fileHandlers.cpp
// Function: writeHeader()
void writeHeader()
{
    ofstream writeStudent;
    writeStudent.open("Output/Student.txt", ios::app);
    writeStudent << setw(7) << "Serial";
    writeStudent << setw(14) << "Roll";
    writeStudent << setw(30) << "Name";
    writeStudent << setw(35) << "Attendance (Present/Total)" << endl
                 << endl;
    writeStudent.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
leaq -0x200(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x3430
movq -0x228(%rbp), %rdi
leaq 0x4d7c(%rip), %rsi      # 0xe548
movl $0x1, %edx
callq 0x3040
jmp 0x97d8
movl $0x7, %edi
callq 0x4890
movl %eax, -0x22c(%rbp)
jmp 0x97ea
movl -0x22c(%rbp), %eax
movl %eax, -0x210(%rbp)
movl -0x210(%rbp), %esi
leaq -0x200(%rbp), %rdi
callq 0x32f0
movq %rax, -0x238(%rbp)
jmp 0x9811
movq -0x238(%rbp), %rdi
leaq 0x491e(%rip), %rsi      # 0xe13d
callq 0x3270
jmp 0x9826
movl $0xe, %edi
callq 0x4890
movl %eax, -0x23c(%rbp)
jmp 0x9838
movl -0x23c(%rbp), %eax
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %esi
leaq -0x200(%rbp), %rdi
callq 0x32f0
movq %rax, -0x248(%rbp)
jmp 0x985f
movq -0x248(%rbp), %rdi
leaq 0x48d7(%rip), %rsi      # 0xe144
callq 0x3270
jmp 0x9874
movl $0x1e, %edi
callq 0x4890
movl %eax, -0x24c(%rbp)
jmp 0x9886
movl -0x24c(%rbp), %eax
movl %eax, -0x218(%rbp)
movl -0x218(%rbp), %esi
leaq -0x200(%rbp), %rdi
callq 0x32f0
movq %rax, -0x258(%rbp)
jmp 0x98ad
movq -0x258(%rbp), %rdi
leaq 0x488e(%rip), %rsi      # 0xe149
callq 0x3270
jmp 0x98c2
movl $0x23, %edi
callq 0x4890
movl %eax, -0x25c(%rbp)
jmp 0x98d4
movl -0x25c(%rbp), %eax
movl %eax, -0x21c(%rbp)
movl -0x21c(%rbp), %esi
leaq -0x200(%rbp), %rdi
callq 0x32f0
movq %rax, -0x268(%rbp)
jmp 0x98fb
movq -0x268(%rbp), %rdi
leaq 0x4845(%rip), %rsi      # 0xe14e
callq 0x3270
movq %rax, -0x270(%rbp)
jmp 0x9917
movq -0x270(%rbp), %rdi
movq 0xa693(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, -0x278(%rbp)
jmp 0x9933
movq -0x278(%rbp), %rdi
movq 0xa677(%rip), %rsi      # 0x13fb8
callq 0x32a0
jmp 0x9948
leaq -0x200(%rbp), %rdi
callq 0x3390
jmp 0x9956
leaq -0x200(%rbp), %rdi
callq 0x33c0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x33c0
movq -0x208(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/fileHandlers.cpp
// Function: writeSl(int)
void writeSl(int sl)
{
    ofstream writeStudent;
    writeStudent.open("Output/Student.txt", ios::app);
    writeStudent << setw(7) << sl;
    writeStudent.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movl %edi, -0x4(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x3430
movq -0x220(%rbp), %rdi
leaq 0x4b79(%rip), %rsi      # 0xe548
movl $0x1, %edx
callq 0x3040
jmp 0x99db
movl $0x7, %edi
callq 0x4890
movl %eax, -0x224(%rbp)
jmp 0x99ed
movl -0x224(%rbp), %eax
movl %eax, -0x218(%rbp)
movl -0x218(%rbp), %esi
leaq -0x208(%rbp), %rdi
callq 0x32f0
movq %rax, -0x230(%rbp)
jmp 0x9a14
movq -0x230(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x3450
jmp 0x9a25
leaq -0x208(%rbp), %rdi
callq 0x3390
jmp 0x9a33
leaq -0x208(%rbp), %rdi
callq 0x33c0
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x33c0
movq -0x210(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/fileHandlers.cpp
// Function: writeRoll(int)
void writeRoll(int roll)
{
    ofstream writeStudent;
    writeStudent.open("Output/Student.txt", ios::app);
    writeStudent << setw(14) << roll;
    writeStudent.close();

    ofstream writeStudentbin;
    writeStudentbin.open(".Data/input.bin", ios::app);
    writeStudentbin << roll << endl;
    writeStudentbin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movl %edi, -0x4(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x420(%rbp)
callq 0x3430
movq -0x420(%rbp), %rdi
leaq 0x4a99(%rip), %rsi      # 0xe548
movl $0x1, %edx
callq 0x3040
jmp 0x9abb
movl $0xe, %edi
callq 0x4890
movl %eax, -0x424(%rbp)
jmp 0x9acd
movl -0x424(%rbp), %eax
movl %eax, -0x218(%rbp)
movl -0x218(%rbp), %esi
leaq -0x208(%rbp), %rdi
callq 0x32f0
movq %rax, -0x430(%rbp)
jmp 0x9af4
movq -0x430(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x3450
jmp 0x9b05
leaq -0x208(%rbp), %rdi
callq 0x3390
jmp 0x9b13
leaq -0x418(%rbp), %rdi
callq 0x3430
jmp 0x9b21
leaq 0x4a33(%rip), %rsi      # 0xe55b
leaq -0x418(%rbp), %rdi
movl $0x1, %edx
callq 0x3040
jmp 0x9b3b
movl -0x4(%rbp), %esi
leaq -0x418(%rbp), %rdi
callq 0x3450
movq %rax, -0x438(%rbp)
jmp 0x9b53
movq -0x438(%rbp), %rdi
movq 0xa457(%rip), %rsi      # 0x13fb8
callq 0x32a0
jmp 0x9b68
leaq -0x418(%rbp), %rdi
callq 0x3390
jmp 0x9b76
leaq -0x418(%rbp), %rdi
callq 0x33c0
leaq -0x208(%rbp), %rdi
callq 0x33c0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x9bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x418(%rbp), %rdi
callq 0x33c0
leaq -0x208(%rbp), %rdi
callq 0x33c0
movq -0x210(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/fileHandlers.cpp
// Function: writeName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void writeName(string name)
{
    ofstream writeStudent;
    writeStudent.open("Output/Student.txt", ios::app);
    writeStudent << setw(30) << name;
    writeStudent.close();

    ofstream writeStudentbin;
    writeStudentbin.open(".Data/input.bin", ios::app);
    writeStudentbin << name << endl;
    writeStudentbin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x428(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x420(%rbp)
callq 0x3430
movq -0x420(%rbp), %rdi
leaq 0x4921(%rip), %rsi      # 0xe548
movl $0x1, %edx
callq 0x3040
jmp 0x9c33
movl $0x1e, %edi
callq 0x4890
movl %eax, -0x42c(%rbp)
jmp 0x9c45
movl -0x42c(%rbp), %eax
movl %eax, -0x218(%rbp)
movl -0x218(%rbp), %esi
leaq -0x208(%rbp), %rdi
callq 0x32f0
movq %rax, -0x438(%rbp)
jmp 0x9c6c
movq -0x428(%rbp), %rsi
movq -0x438(%rbp), %rdi
callq 0x3260
jmp 0x9c81
leaq -0x208(%rbp), %rdi
callq 0x3390
jmp 0x9c8f
leaq -0x418(%rbp), %rdi
callq 0x3430
jmp 0x9c9d
leaq 0x48b7(%rip), %rsi      # 0xe55b
leaq -0x418(%rbp), %rdi
movl $0x1, %edx
callq 0x3040
jmp 0x9cb7
movq -0x428(%rbp), %rsi
leaq -0x418(%rbp), %rdi
callq 0x3260
movq %rax, -0x440(%rbp)
jmp 0x9cd3
movq -0x440(%rbp), %rdi
movq 0xa2d7(%rip), %rsi      # 0x13fb8
callq 0x32a0
jmp 0x9ce8
leaq -0x418(%rbp), %rdi
callq 0x3390
jmp 0x9cf6
leaq -0x418(%rbp), %rdi
callq 0x33c0
leaq -0x208(%rbp), %rdi
callq 0x33c0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x9d49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x418(%rbp), %rdi
callq 0x33c0
leaq -0x208(%rbp), %rdi
callq 0x33c0
movq -0x210(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/fileHandlers.cpp
// Function: AllReset()
void AllReset()
{
    char filename[] = "Output/Student.txt";
    char binfilename[] = ".Data/input.bin";
    char binfileAttendance[] = ".Data/Attendance.bin";
    int garbage = remove(filename);
    garbage = remove(binfilename);
    garbage = remove(binfileAttendance);
    for (int i = 0; i < Student.size(); i++)
    {
        Student.pop_back();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x3ca1(%rip), %rax      # 0xe320
movq %rax, -0x20(%rbp)
movq 0x3c9e(%rip), %rax      # 0xe328
movq %rax, -0x18(%rbp)
movw 0x3c9b(%rip), %ax       # 0xe330
movw %ax, -0x10(%rbp)
movb 0x3c93(%rip), %al       # 0xe332
movb %al, -0xe(%rbp)
movq 0x3c97(%rip), %rax      # 0xe340
movq %rax, -0x30(%rbp)
movq 0x3c94(%rip), %rax      # 0xe348
movq %rax, -0x28(%rbp)
movq 0x3c91(%rip), %rax      # 0xe350
movq %rax, -0x50(%rbp)
movq 0x3c8e(%rip), %rax      # 0xe358
movq %rax, -0x48(%rbp)
movl 0x3c8c(%rip), %eax      # 0xe360
movl %eax, -0x40(%rbp)
movb 0x3c87(%rip), %al       # 0xe364
movb %al, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x34a0
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34a0
movl %eax, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34a0
movl %eax, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x9b96(%rip), %rdi      # 0x142b0
callq 0x4860
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0xa742
leaq 0x9b7e(%rip), %rdi      # 0x142b0
callq 0xa7f0
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xa70b
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/logInPage.cpp
// Function: logInPageHeader()
void logInPageHeader()
{
    cout << endl
         << "      #######################################" << endl
         << "      #              Login Page             #" << endl
         << "      #######################################" << endl
         << endl;
    cout << "                 Enter Login Details" << endl
         << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8e75(%rip), %rdi      # 0x13fd0
movq 0x8e56(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x346c(%rip), %rsi      # 0xe5dd
callq 0x3270
movq %rax, %rdi
movq 0x8e38(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x347c(%rip), %rsi      # 0xe60b
callq 0x3270
movq %rax, %rdi
movq 0x8e1a(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x3430(%rip), %rsi      # 0xe5dd
callq 0x3270
movq %rax, %rdi
movq 0x8dfc(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x8ded(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0x8df9(%rip), %rdi      # 0x13fd0
leaq 0x345b(%rip), %rsi      # 0xe639
callq 0x3270
movq %rax, %rdi
movq 0x8dcb(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x8dbc(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/main.cpp
// Function: main
int main()
{
    system("CLS");
    welcomePageHeader();
    welcomePage();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x2fd5(%rip), %rdi      # 0xe1fb
callq 0x3230
callq 0x96a0
callq 0x9610
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/pastAttendance.cpp
// Function: pastAttendanceHeader()
void pastAttendanceHeader()
{
     cout << endl
          << "      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" << endl
          << "      %            Past Attendance          %" << endl
          << "      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" << endl
          << endl;
     cout << "                Choose your option" << endl
          << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8715(%rip), %rdi      # 0x13fd0
movq 0x86f6(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x2e12(%rip), %rsi      # 0xe6e3
callq 0x3270
movq %rax, %rdi
movq 0x86d8(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x2e22(%rip), %rsi      # 0xe711
callq 0x3270
movq %rax, %rdi
movq 0x86ba(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x2dd6(%rip), %rsi      # 0xe6e3
callq 0x3270
movq %rax, %rdi
movq 0x869c(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x868d(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0x8699(%rip), %rdi      # 0x13fd0
leaq 0x2e01(%rip), %rsi      # 0xe73f
callq 0x3270
movq %rax, %rdi
movq 0x866b(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x865c(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/takeAttendance.cpp
// Function: takeAttendanceHeader()
void takeAttendanceHeader()
{
    cout << endl
         << "      ======================================" << endl
         << "      =            Take Attendance         =" << endl
         << "      ======================================" << endl
         << endl;
    cout << "                Choose your option" << endl
         << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x76e5(%rip), %rdi      # 0x13fd0
movq 0x76c6(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x1f41(%rip), %rsi      # 0xe842
callq 0x3270
movq %rax, %rdi
movq 0x76a8(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x1f50(%rip), %rsi      # 0xe86f
callq 0x3270
movq %rax, %rdi
movq 0x768a(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x1f05(%rip), %rsi      # 0xe842
callq 0x3270
movq %rax, %rdi
movq 0x766c(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x765d(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0x7669(%rip), %rdi      # 0x13fd0
leaq 0x1dd1(%rip), %rsi      # 0xe73f
callq 0x3270
movq %rax, %rdi
movq 0x763b(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x762c(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TasnimAnas[P]Attendance-Management-System/src/userHome.cpp
// Function: userHomeHeader()
void userHomeHeader()
{
    cout << endl
         << "      ======================================" << endl
         << "      =             Welcome User           =" << endl
         << "      ======================================" << endl
         << endl;
    cout << "                Choose your option" << endl
         << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x6d45(%rip), %rdi      # 0x13fd0
movq 0x6d26(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x15a1(%rip), %rsi      # 0xe842
callq 0x3270
movq %rax, %rdi
movq 0x6d08(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x16ef(%rip), %rsi      # 0xe9ae
callq 0x3270
movq %rax, %rdi
movq 0x6cea(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
leaq 0x1565(%rip), %rsi      # 0xe842
callq 0x3270
movq %rax, %rdi
movq 0x6ccc(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x6cbd(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq 0x6cc9(%rip), %rdi      # 0x13fd0
leaq 0x1431(%rip), %rsi      # 0xe73f
callq 0x3270
movq %rax, %rdi
movq 0x6c9b(%rip), %rsi      # 0x13fb8
callq 0x32a0
movq %rax, %rdi
movq 0x6c8c(%rip), %rsi      # 0x13fb8
callq 0x32a0
popq %rbp
retq
// File: neguse[P]no/lang.cc
// Function: hex2i(char)
int hex2i(char c) {
  if ('0' <= c && c <= '9') {
    return c - '0';
  } else {
    return (c - 'a') + 0xa;
  }
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x234d
movsbl -0x5(%rsp), %eax
cmpl $0x39, %eax
jg 0x234d
movsbl -0x5(%rsp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rsp)
jmp 0x235c
movsbl -0x5(%rsp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: neguse[P]no/lang.cc
// Function: main
int main(int argc, char **argv) {
  if (argc != 2) {
    printf("Usage: ./no <program>\n");
    return 1;
  }

  Input input(argv[1]);
  if (!input.ok()) {
    printf("failed to open file\n");
    return 2;
  }

  char c;
  int level = 0;
  Lang l;

  auto n = l.Parse(input);
  // l.Print(n);
  if (!l.Validate(n)) {
    return 3;
  }

  auto i = LangInterpreter();
  i.Exec(n);

  return 0;
}

// Assembly:
subq $0xc8, %rsp
movl $0x0, 0xc4(%rsp)
movl %edi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
cmpl $0x2, 0xc0(%rsp)
je 0x23b9
leaq 0xed0e(%rip), %rdi      # 0x110b0
movb $0x0, %al
callq 0x2030
movl $0x1, 0xc4(%rsp)
jmp 0x2567
movq 0xb8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x2580
leaq 0xa8(%rsp), %rdi
callq 0x25e0
testb $0x1, %al
jne 0x2401
leaq 0xecdd(%rip), %rdi      # 0x110c7
movb $0x0, %al
callq 0x2030
movl $0x2, 0xc4(%rsp)
jmp 0x2567
movl $0x0, 0xa0(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2600
movq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x4740
jmp 0x2434
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x4910
movq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x4820
movb %al, 0x1f(%rsp)
jmp 0x245d
movb 0x1f(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4940
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x247b
jmp 0x24c3
movl $0x3, 0xc4(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x253b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x255b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4940
jmp 0x2551
leaq 0x3b(%rsp), %rdi
callq 0x4950
jmp 0x24cf
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x60(%rsp), %rsi
callq 0x4910
movq (%rsp), %rsi
leaq 0x3b(%rsp), %rdi
callq 0x4960
jmp 0x24f2
leaq 0x28(%rsp), %rdi
callq 0x4940
movl $0x0, 0xc4(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x253b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2551
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4940
jmp 0x2551
leaq 0x60(%rsp), %rdi
callq 0x4940
leaq 0x70(%rsp), %rdi
callq 0x5200
jmp 0x2567
leaq 0x60(%rsp), %rdi
callq 0x4940
leaq 0x70(%rsp), %rdi
callq 0x5200
jmp 0x2576
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x21d0
// File: neguse[P]no/lang.cc
// Function: Lang::Parse(Input&)
Node::Ref Parse(Input &input) {
    auto n = ParseNode(input);
    auto e = ParseNode(input);
    assert(e == nullptr);
    return n;
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x40(%rsp), %rdx
xorl %ecx, %ecx
movl %ecx, 0x18(%rsp)
callq 0x7ea0
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %ecx
movq 0x40(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x7ea0
jmp 0x4798
leaq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x81b0
testb $0x1, %al
jne 0x47ac
jmp 0x47ae
jmp 0x47e6
leaq 0xc958(%rip), %rdi      # 0x1110d
leaq 0xc95e(%rip), %rsi      # 0x1111a
movl $0x115, %edx            # imm = 0x115
leaq 0xc95a(%rip), %rcx      # 0x11122
callq 0x20d0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x4940
jmp 0x480f
movb $0x1, 0x3f(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4940
testb $0x1, 0x3f(%rsp)
jne 0x4805
movq (%rsp), %rdi
callq 0x4940
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21d0
nopl (%rax)
// File: neguse[P]no/lang.cc
// Function: Input::Get()
char Get() {
    char c = fgetc(fp_);
    if (c == '\n') {
      pos_.line++;
      pos_.col = 0;
    } else if (c == '\t') {
      pos_.col += 4;
    } else if (c == EOF) {
    } else {
      pos_.col++;
    }
    return c;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rdi
callq 0x21a0
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0x821e
movq (%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0xc(%rax)
jmp 0x8254
movsbl 0xf(%rsp), %eax
cmpl $0x9, %eax
jne 0x8237
movq (%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0xc(%rax)
jmp 0x8252
movsbl 0xf(%rsp), %eax
cmpl $-0x1, %eax
jne 0x8243
jmp 0x8250
movq (%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x8252
jmp 0x8254
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: neguse[P]no/lang.cc
// Function: LangInterpreter::Frame::Set(char, std::shared_ptr<LangInterpreter::Value>)
void Set(char c, std::shared_ptr<Value> v) {
      auto it = m.find(c);
      if (it != m.end()) {
        it->second = v;
      } else {
        if (parent == nullptr) {
          m[c] = v;
        } else {
          parent->Set(c, v);
        }
      }
    }

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x20(%rsp)
movb %sil, %al
movq %rdi, 0x70(%rsp)
movb %al, 0x6f(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x10, %rdi
leaq 0x6f(%rsp), %rsi
callq 0xdd10
movq 0x28(%rsp), %rdi
movq %rax, 0x58(%rsp)
addq $0x10, %rdi
callq 0xdd60
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xdd40
testb $0x1, %al
jne 0x9c6f
jmp 0x9c8f
leaq 0x58(%rsp), %rdi
callq 0xdd90
movq 0x20(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0xddb0
jmp 0x9d2e
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdde0
testb $0x1, %al
jne 0x9ca3
jmp 0x9cc5
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
leaq 0x6f(%rsp), %rsi
callq 0xde10
movq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xddb0
jmp 0x9d2c
movq 0x28(%rsp), %rdi
callq 0x9c00
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
movsbl 0x6f(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9d40
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x9c10
jmp 0x9d06
leaq 0x40(%rsp), %rdi
callq 0x9d70
jmp 0x9d2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x9d70
jmp 0x9d33
jmp 0x9d2e
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x21d0
nopl (%rax)
// File: neguse[P]no/lang.cc
// Function: LangInterpreter::PrintAsString(std::shared_ptr<LangInterpreter::Value>)
void PrintAsString(Value::Ref v) {
    if (v->kind == ValueKind::Integer) {
      printf("%d\n", v->GetInteger());
    } else if (v->kind == ValueKind::List) {
      for (auto row = v; row->GetList() != nullptr; row = row->GetList()->cdr) {
        for (auto col = row->GetList()->car; col->GetList() != nullptr;
             col = col->GetList()->cdr) {
          printf("%c", col->GetList()->car->GetInteger());
        }
        printf("\n");
      }
    }
  }

// Assembly:
subq $0xc8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
callq 0x9ae0
cmpl $0x0, (%rax)
jne 0xb89a
movq 0x18(%rsp), %rdi
callq 0x9ae0
movq %rax, %rdi
callq 0xf260
movl %eax, %esi
leaq 0x5ac1(%rip), %rdi      # 0x1134f
movb $0x0, %al
callq 0x2030
jmp 0xbaf7
movq 0x18(%rsp), %rdi
callq 0x9ae0
cmpl $0x1, (%rax)
jne 0xbaf5
movq 0x18(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x9d40
leaq 0xa8(%rsp), %rdi
callq 0x9ae0
movq %rax, %rsi
leaq 0x98(%rsp), %rdi
callq 0xf1c0
leaq 0x98(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10750
movb %al, 0xf(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x9dd0
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb923
movl $0x2, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x9d70
jmp 0xbaf3
leaq 0xa8(%rsp), %rdi
callq 0x9ae0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0xf1c0
leaq 0x70(%rsp), %rdi
callq 0xf230
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x9d40
leaq 0x70(%rsp), %rdi
callq 0x9dd0
leaq 0x80(%rsp), %rdi
callq 0x9ae0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0xf1c0
leaq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10750
movb %al, 0xe(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x9dd0
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0xb9bc
movl $0x5, 0x94(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x9d70
jmp 0xba7d
leaq 0x80(%rsp), %rdi
callq 0x9ae0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf1c0
movq (%rsp), %rdi
callq 0xf230
movq %rax, %rdi
callq 0x9ae0
movq %rax, %rdi
callq 0xf260
movl %eax, %esi
leaq 0x5957(%rip), %rdi      # 0x11353
xorl %eax, %eax
callq 0x2030
jmp 0xba05
leaq 0x50(%rsp), %rdi
callq 0x9dd0
leaq 0x80(%rsp), %rdi
callq 0x9ae0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0xf1c0
leaq 0x30(%rsp), %rdi
callq 0xf230
movq %rax, %rsi
addq $0x10, %rsi
leaq 0x80(%rsp), %rdi
callq 0xddb0
leaq 0x30(%rsp), %rdi
callq 0x9dd0
jmp 0xb961
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x9dd0
leaq 0x80(%rsp), %rdi
callq 0x9d70
jmp 0xbae4
leaq 0x5726(%rip), %rdi      # 0x111aa
xorl %eax, %eax
callq 0x2030
jmp 0xba8d
jmp 0xba8f
leaq 0xa8(%rsp), %rdi
callq 0x9ae0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0xf1c0
leaq 0x20(%rsp), %rdi
callq 0xf230
movq %rax, %rsi
addq $0x10, %rsi
leaq 0xa8(%rsp), %rdi
callq 0xddb0
leaq 0x20(%rsp), %rdi
callq 0x9dd0
jmp 0xb8bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x9d70
jmp 0xbaff
jmp 0xbaf5
jmp 0xbaf7
addq $0xc8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x21d0
nopl (%rax)
// File: neguse[P]no/lang.cc
// Function: LangInterpreter::ReadI()
Value::Ref ReadI() {
    int i = 0;
    std::cin >> i;
    Value::Ref v = std::make_shared<Value>();
    v->SetInteger(i);
    return v;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x9f57(%rip), %rdi      # 0x18fe0
leaq 0x24(%rsp), %rsi
callq 0x20b0
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
callq 0x9a70
movq 0x8(%rsp), %rdi
callq 0x9ae0
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0xf240
jmp 0xf0ba
movb $0x1, 0x23(%rsp)
testb $0x1, 0x23(%rsp)
jne 0xf0ec
jmp 0xf0e2
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x9d70
jmp 0xf0f5
movq 0x8(%rsp), %rdi
callq 0x9d70
movq (%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x21d0
nop
// File: neguse[P]no/lang.cc
// Function: LangInterpreter::ReadS()
Value::Ref ReadS() {
    std::string s;
    std::cin >> s;
    Value::Ref v = StringToList(s.c_str());
    return v;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2160
movq 0x20(%rsp), %rsi
movq 0x9ea0(%rip), %rdi      # 0x18fe0
callq 0x2150
jmp 0xf147
movb $0x0, 0x2b(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2080
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0xf660
jmp 0xf16a
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0xf19c
jmp 0xf192
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x20c0
jmp 0xf1b0
movq 0x8(%rsp), %rdi
callq 0x9d70
leaq 0x38(%rsp), %rdi
callq 0x20c0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21d0
nopw (%rax,%rax)
// File: neguse[P]no/lang.cc
// Function: LangInterpreter::Value::True()
bool True() {
      switch (kind) {
      case ValueKind::Integer:
        return v.i != 0;
      case ValueKind::List:
        return v.c != nullptr;
      case ValueKind::Closure:
        return v.l != nullptr;
      }
      assert(0);
      return false;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0xf405
jmp 0xf3ef
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0xf419
jmp 0xf3fa
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0xf437
jmp 0xf455
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xf474
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10730
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xf474
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10750
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xf474
leaq 0x1dec(%rip), %rdi      # 0x11248
leaq 0x1cb7(%rip), %rsi      # 0x1111a
movl $0x1d2, %edx            # imm = 0x1D2
leaq 0x1ebc(%rip), %rcx      # 0x1132b
callq 0x20d0
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop