LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Sooryakiran[P]dotV/src/verilog.cpp
// Function: Chip::num_transistors()
int Chip::num_transistors(){
    /*------------------------------------------------------------------------------------------
    This function recursively iterates through all the submodules and behaviours if any to count
    the number of transistors required to create an instance.

    Params : None
    Returns : total (int), transitor count.                         
    ------------------------------------------------------------------------------------------*/
    int total = this->transistors;
    
    for(vector<Chip>::iterator sub = this->submodules.begin();
                               sub != this->submodules.end();
                               sub++){

        total += sub->num_transistors();
    }

    for(vector<BehaviourModel>::iterator sub = this->behaviours.begin();
                                         sub != this->behaviours.end();
                                         sub ++){
        total += sub->num_transistors;
    }

    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x60(%rdi), %ebx
movq 0x68(%rdi), %r15
movq 0x70(%rdi), %r12
cmpq %r12, %r15
je 0x8081
movq %r15, %rdi
callq 0x7530
addl %eax, %ebx
addq $0x198, %r15            # imm = 0x198
jmp 0x8069
movq 0x178(%r14), %rax
movq 0x180(%r14), %rcx
cmpq %rcx, %rax
je 0x809c
addl (%rax), %ebx
addq $0x38, %rax
jmp 0x808f
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sooryakiran[P]dotV/src/verilog.cpp
// Function: BehaviourModel::code[abi:cxx11]()
string BehaviourModel::code(){
    /*------------------------------------------------------------------------------------------
    TReturns the verilog code for the current behaviour as string.

    Returns: outs(string), verilog code for the current behaviour.
    ------------------------------------------------------------------------------------------*/
    string outs = "always @(";
    
    for(vector<string>::iterator i = this->sensitivity_list.begin(); i != this->sensitivity_list.end(); i++){
        if(i != this->sensitivity_list.begin()){
            outs += " or ";
        }
        outs += *i;
    }
    outs += ")\nbegin";

    for(vector<string>::iterator i = this->statements.begin(); i != this->statements.end(); i++){
        outs += "\n\t" + *i + ";";
    }
    outs +="\nend";
    return outs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
leaq 0x2c818(%rip), %rsi     # 0x36147
leaq 0x2c81a(%rip), %rdx     # 0x36150
callq 0x7200
movq 0x20(%r14), %r12
cmpq 0x28(%r14), %r12
je 0x9978
leaq 0x2c805(%rip), %r15     # 0x36151
cmpq 0x20(%r14), %r12
je 0x995d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7910
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x7140
addq $0x20, %r12
cmpq 0x28(%r14), %r12
jne 0x994c
leaq 0x2c7d7(%rip), %rsi     # 0x36156
movq %rbx, %rdi
callq 0x7910
movq 0x8(%r14), %r15
cmpq 0x10(%r14), %r15
je 0x9a49
leaq -0x38(%rbp), %r12
leaq -0x70(%rbp), %r13
movq %r13, %rdi
leaq 0x2c788(%rip), %rsi     # 0x3612f
movq %r15, %rdx
callq 0x7480
movq %r13, %rdi
leaq 0x2cd59(%rip), %rsi     # 0x36712
callq 0x7910
movq %r12, -0x48(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x99de
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x99e6
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x7140
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9a22
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x7510
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x9a3b
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x7510
addq $0x20, %r15
cmpq 0x10(%r14), %r15
jne 0x999d
leaq 0x2c70e(%rip), %rsi     # 0x3615e
movq %rbx, %rdi
callq 0x7910
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9aa6
jmp 0x9aa6
movq %rax, %r14
jmp 0x9a8b
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x9a8b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x7510
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x9aa9
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x7510
jmp 0x9aa9
movq %rax, %r14
movq (%rbx), %rdi
movq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x9ac0
movq (%rax), %rsi
incq %rsi
callq 0x7510
movq %r14, %rdi
callq 0x7870
// File: /workspace/github_cpp_makefile_star2_O3/Sooryakiran[P]dotV/src/verilog.cpp
// Function: BehaviourModel::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void BehaviourModel::add(string lhs, string rhs, bool is_blocking){
    /*------------------------------------------------------------------------------------------
    Adds a new statement to the behaviour model.

    Param: lhs(string), Left hand side of the statement.
    Param: rhs(string), Right hand side of the statment.
    Param: is_blocking(bool), BLOCK/N_BLOCK for blovking or non blocking statements
    ------------------------------------------------------------------------------------------*/
    string asg = (is_blocking)? " = " : " <= " ;
    string expr = lhs + asg + rhs;
    this->statements.push_back(expr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2c5ff(%rip), %rax     # 0x3613e
leaq 0x2c5fc(%rip), %rsi     # 0x36142
testl %ecx, %ecx
cmovneq %rax, %rsi
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movl %ecx, %eax
movq %rsi, %rdx
subq %rax, %rdx
addq $0x4, %rdx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x7200
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7930
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x68(%rbp), %rdi
callq 0x7140
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9bb2
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x9bb9
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9be9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x7510
addq $0x8, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x72a0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x9c0e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x7510
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x9c26
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x7510
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x9c68
movq -0x38(%rbp), %rsi
jmp 0x9c5b
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c68
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x7510
jmp 0x9c68
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x9c80
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x7510
movq %rbx, %rdi
callq 0x7870
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/main.cc
// Function: ValidateCommanderId(std::vector<net::Address, std::allocator<net::Address>>&, int)
void ValidateCommanderId(generals::ProcessList& processes, int commander_id) {
  // Make sure the commander_id is valid
  if (commander_id < 0 || (size_t)commander_id >= processes.size()) {
    throw args::ValidationError("commander_id does not reference a process");
  }
  // Move the commander to the first element in the vector
  std::iter_swap(processes.begin(), processes.begin() + commander_id);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testl %esi, %esi
js 0x6bf4
movl %esi, %eax
movq (%rdi), %rbx
movq 0x8(%rdi), %rcx
subq %rbx, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x6bf4
leaq (%rax,%rax,4), %rax
leaq (%rbx,%rax,8), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rcx
leaq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x6b7c
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x6b84
movups (%rax), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rbx), %rcx
leaq 0x8(%rsp), %r15
movq %rcx, 0x8(%r15)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzwl 0x20(%rbx), %eax
movw %ax, 0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53f0
movzwl 0x20(%r14), %eax
movw %ax, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x53f0
movzwl 0x20(%r15), %eax
movw %ax, 0x20(%r14)
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6be7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfd49(%rip), %rsi      # 0x1695a
leaq 0xfd6b(%rip), %rdx      # 0x16983
leaq 0x8(%rsp), %rdi
callq 0xe30c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5410
leaq 0x18927(%rip), %rax     # 0x1f560
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18843(%rip), %rsi     # 0x1f488
movq 0x19334(%rip), %rdx     # 0x1ff80
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
testb %bpl, %bpl
jne 0x6c78
jmp 0x6c80
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/main.cc
// Function: ValidateFaultyCount(std::vector<net::Address, std::allocator<net::Address>> const&, int)
void ValidateFaultyCount(const generals::ProcessList& processes, int faulty) {
  if (faulty < 0) {
    throw args::ValidationError("faulty count must be non-negative");
  }
  if ((size_t)faulty + 2 > processes.size()) {
    throw args::ValidationError(
        "the total number of processes must be no less than (faulty + 2)");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %esi, %esi
js 0x6cc2
addl $0x2, %esi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
cmpq %rsi, %rcx
jb 0x6d24
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfca5(%rip), %rsi      # 0x16984
leaq 0xfcbf(%rip), %rdx      # 0x169a5
leaq 0x8(%rsp), %rdi
callq 0xe30c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5410
leaq 0x18859(%rip), %rax     # 0x1f560
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18775(%rip), %rsi     # 0x1f488
movq 0x19266(%rip), %rdx     # 0x1ff80
movq %rbx, %rdi
callq 0x55d0
jmp 0x6d84
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfc65(%rip), %rsi      # 0x169a6
leaq 0xfc9d(%rip), %rdx      # 0x169e5
leaq 0x8(%rsp), %rdi
callq 0xe30c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5410
leaq 0x187f7(%rip), %rax     # 0x1f560
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18713(%rip), %rsi     # 0x1f488
movq 0x19204(%rip), %rdx     # 0x1ff80
movq %rbx, %rdi
callq 0x55d0
jmp 0x6d88
jmp 0x6da9
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6da2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
testb %bpl, %bpl
jne 0x6dac
jmp 0x6db4
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/include/args.h
// Function: args::ValueFlagList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector, args::ValueReader<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::Reset()
virtual void Reset() noexcept {
    matched = false;
#ifdef ARGS_NOEXCEPT
    error = Error::None;
#endif
  }

// Assembly:
movb $0x0, 0x8(%rdi)
movq 0xc8(%rdi), %rsi
addq $0xc8, %rdi
jmp 0xf8fe
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/include/args.h
// Function: args::ValueFlagList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector, args::ValueReader<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::ParseValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void ParseValue(const std::string &value_) override {
    T v;
#ifdef ARGS_NOEXCEPT
    if (!reader(name, value_, v)) {
      error = Error::Parse;
    }
#else
    reader(name, value_, v);
#endif
    values.insert(std::end(values), v);
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x51e0
movq 0xd0(%rbx), %rsi
addq $0xc8, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xf950
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xf84b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xf855
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xf86f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/udp_conn.cc
// Function: udp::Client::Send(char const*, unsigned long) const
void Client::Send(const char *buf, size_t size) const {
  auto addr = remote_address_.addr();
  auto addrlen = remote_address_.addr_len();
  if (sendto(sockfd_, buf, size, 0, addr, addrlen) < 0) {
    throw net::SendException();
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x10(%rdi), %eax
leaq 0x14(%rdi), %r8
movl %eax, %edi
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x5060
testq %rax, %rax
js 0x10391
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x10882
leaq 0xf6ab(%rip), %rsi      # 0x1fa58
leaq 0x624(%rip), %rdx       # 0x109d8
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/udp_conn.cc
// Function: udp::Client::SendWithAck(char const*, unsigned long, unsigned int, std::function<udp::ServerAction (std::shared_ptr<udp::Client const>, char*, unsigned long)>) const
void Client::SendWithAck(const char *buf, size_t size, unsigned int attempts,
                         OnReceiveFn validAck) const {
  bool noLimit = attempts == 0;
  for (; noLimit || attempts > 0; --attempts) {
    // Send the message to the client.
    Send(buf, size);

    // Create a zeroed out buffer to read the ack message into.
    char ackbuf[BUFSIZE];
    bzero(ackbuf, BUFSIZE);

    // receive from the socket.
    struct sockaddr_in clientaddr;
    socklen_t clientlen = sizeof(clientaddr);
    int n = recvfrom(sockfd_, ackbuf, BUFSIZE, 0,
                     (struct sockaddr *)&clientaddr, &clientlen);

    // Check for error cases. This is either a timeout or some kind of
    // networking error. For timeouts, try sending the message again. For
    // anything else, throw an exception.
    if (n < 0) {
      if (IsErrnoTimeout()) {
        continue;
      } else {
        throw net::ReceiveException();
      }
    }

    // Make sure the ack was valid.
    auto action = validAck(shared_from_this(), ackbuf, n);
    if (action == ServerAction::Stop) {
      return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
movq %r8, %rbx
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq %rcx, 0x8(%rsp)
leal -0x1(%rcx), %r12d
leaq 0x50(%rsp), %rbp
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x1036a
movl $0x400, %edx            # imm = 0x400
movq %rbp, %rdi
xorl %esi, %esi
callq 0x51f0
movl $0x10, 0x4(%rsp)
movl 0x10(%r13), %edi
movl $0x400, %edx            # imm = 0x400
movq %rbp, %rsi
xorl %ecx, %ecx
leaq 0x40(%rsp), %r8
leaq 0x4(%rsp), %r9
callq 0x5290
movq %rax, %r15
testl %r15d, %r15d
js 0x104a2
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x10bbc
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq %rbp, 0x28(%rsp)
movq %r15, 0x20(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x104df
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *0x18(%rbx)
movl %eax, %r15d
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1049a
callq 0xff02
cmpl $0x1, %r15d
jne 0x104b3
jmp 0x104cd
callq 0x5040
movl (%rax), %eax
cmpl $0xb, %eax
je 0x104b3
cmpl $0x6f, %eax
jne 0x104e4
addl $-0x1, %r12d
setb %al
cmpl $0x0, 0x8(%rsp)
je 0x103ff
testb %al, %al
jne 0x103ff
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5140
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x108f4
leaq 0xf570(%rip), %rsi      # 0x1fa70
leaq 0x4d1(%rip), %rdx       # 0x109d8
movq %r14, %rdi
callq 0x55d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5270
jmp 0x10530
jmp 0x1051e
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x10530
callq 0xff02
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/message.cc
// Function: msg::OrderString[abi:cxx11](msg::Order)
std::string OrderString(Order o) {
  switch (o) {
    case Order::RETREAT:
      return "retreat";
    case Order::ATTACK:
      return "attack";
    case Order::NO_ORDER:
      return "no order";
    default:
      throw std::invalid_argument("unexpected Order value");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x10f2f
cmpl $0x1, %esi
je 0x10f18
testl %esi, %esi
jne 0x10f57
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6409(%rip), %rsi      # 0x17318
leaq 0x6409(%rip), %rdx      # 0x1731f
jmp 0x10f44
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x63fa(%rip), %rsi      # 0x17320
leaq 0x63f9(%rip), %rdx      # 0x17326
jmp 0x10f44
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6414(%rip), %rsi      # 0x17351
leaq 0x6415(%rip), %rdx      # 0x17359
movq %rbx, %rdi
callq 0xe30c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x63ef(%rip), %rsi      # 0x1735a
movq %rax, %rdi
callq 0x5650
movq 0xf04e(%rip), %rsi      # 0x1ffc8
movq 0xf027(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/message.cc
// Function: msg::operator<(msg::Message const&, msg::Message const&)
bool operator<(const Message& lhs, const Message& rhs) {
  if (lhs.round != rhs.round) {
    return lhs.round < rhs.round;
  }
  if (lhs.ids != rhs.ids) {
    return lhs.ids < rhs.ids;
  }
  return lhs.order < rhs.order;
}

// Assembly:
movl (%rsi), %eax
cmpl %eax, (%rdi)
jne 0x11031
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r13
movq %r13, %rdx
subq %r14, %rdx
movq 0x8(%rsi), %rbx
movq 0x10(%rsi), %r8
movq %r8, %rbp
subq %rbx, %rbp
cmpq %rbp, %rdx
jne 0x11003
cmpq %r14, %r13
je 0x11035
movq %r14, %rdi
movq %rbx, %rsi
movq %r8, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
callq 0x5360
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r8
testl %eax, %eax
je 0x11035
leaq (%r14,%rbp), %rax
cmpq %rdx, %rbp
cmovlq %rax, %r13
cmpq %r14, %r13
je 0x11029
movl (%r14), %eax
movl (%rbx), %ecx
cmpl %eax, %ecx
jne 0x11043
addq $0x4, %r14
addq $0x4, %rbx
cmpq %r13, %r14
jne 0x11013
cmpq %r8, %rbx
setne %al
jmp 0x11046
setb %al
retq
movl 0x4(%r12), %eax
cmpl 0x4(%r15), %eax
setl %al
jmp 0x11046
seta %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::Message const&)
std::ostream& operator<<(std::ostream& o, const Message& m) {
  o << "{round: " << m.round << ", order: " << OrderString(m.order)
    << ", ids: <";
  for (size_t i = 0; i < m.ids.size(); ++i) {
    if (i > 0) o << ' ';
    o << m.ids[i];
  }
  o << ">}";
  return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6304(%rip), %rsi      # 0x17371
movl $0x8, %edx
callq 0x53c0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x5220
movq %rax, %r15
leaq 0x62ee(%rip), %rsi      # 0x1737a
movl $0x9, %edx
movq %rax, %rdi
callq 0x53c0
movl 0x4(%r14), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x10eec
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x53c0
leaq 0x62c2(%rip), %rsi      # 0x17384
movl $0x8, %edx
movq %rax, %rdi
callq 0x53c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x110ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x1113d
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
testq %r12, %r12
je 0x1111a
movb $0x20, 0x8(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x53c0
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x5220
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x110fc
leaq 0x6249(%rip), %rsi      # 0x1738d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x53c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1117e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::ByzantineMsgFromBuf(char*, unsigned long)
std::experimental::optional<msg::Message> ByzantineMsgFromBuf(char* buf,
                                                              size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n < sizeof(msg::ByzantineMessage)) {
    return {};
  }

  // Copy out the message part.
  msg::Message msg;
  msg::ByzantineMessage* c_msg = reinterpret_cast<msg::ByzantineMessage*>(buf);
  msg.round = ntohl(c_msg->round);
  msg.order = static_cast<msg::Order>(ntohl(c_msg->order));

  msg.ids.resize((n - sizeof(*c_msg)) / sizeof(uint32_t));
  uint32_t* id_buf = reinterpret_cast<uint32_t*>(buf + sizeof(*c_msg));
  for (size_t i = 0; i < msg.ids.size(); ++i) {
    msg.ids[i] = ntohl(id_buf[i]);
  }

  return msg;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0xf, %rdx
ja 0x112e6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
jmp 0x1136b
movq %rsi, %r14
leaq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x8(%rsi), %eax
bswapl %eax
movl %eax, -0x8(%rdi)
movl 0xc(%rsi), %eax
bswapl %eax
movl %eax, -0x4(%rdi)
addq $-0x10, %rdx
shrq $0x2, %rdx
movq %rdx, %rsi
callq 0x12db6
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rax, %rdx
subq %rcx, %rdx
je 0x1134e
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movl 0x10(%r14,%rsi,4), %edi
bswapl %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x1133c
movq 0x8(%rsp), %rdx
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rbx)
movb $0x1, 0x20(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x11390
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5340
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::RoundOfAck(char*, unsigned long)
std::experimental::optional<unsigned int> RoundOfAck(char* buf, size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n != sizeof(msg::Ack)) {
    return {};
  }

  msg::Ack* ack = reinterpret_cast<msg::Ack*>(buf);
  return ntohl(ack->round);
}

// Assembly:
movq %rdi, %rax
cmpq $0xc, %rdx
jne 0x113ac
movl 0x8(%rsi), %ecx
bswapl %ecx
movl %ecx, (%rax)
movb $0x1, %cl
jmp 0x113b5
movq $0x0, (%rax)
xorl %ecx, %ecx
movb %cl, 0x4(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::SendAckForRound(std::shared_ptr<udp::Client const>, unsigned int)
void SendAckForRound(udp::ClientPtr client, unsigned int round) {
  msg::Ack ack = {};
  ack.type = htonl(kAckType);
  ack.size = htonl(sizeof(ack));
  ack.round = htonl(round);

  char* buf = reinterpret_cast<char*>(&ack);
  client->Send(buf, sizeof(ack));
}

// Assembly:
subq $0x18, %rsp
movabsq $0xc00000002000000, %rcx # imm = 0xC00000002000000
leaq 0xc(%rsp), %rax
movq %rcx, (%rax)
bswapl %esi
movl %esi, 0x8(%rax)
movq (%rdi), %rdi
movl $0xc, %edx
movq %rax, %rsi
callq 0x1036a
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::StringToMaliciousBehavior(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MaliciousBehavior StringToMaliciousBehavior(std::string str) {
  if (str == "silent") return MaliciousBehavior::SILENT;
  if (str == "delay_send") return MaliciousBehavior::DELAY_SEND;
  if (str == "partial_send") return MaliciousBehavior::PARTIAL_SEND;
  if (str == "wrong_order") return MaliciousBehavior::WRONG_ORDER;
  throw std::invalid_argument(
      "malicious behavior can one of {\"silent\", \"delay_send\", "
      "\"partial_send\", \"wrong_order\"}");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5ff6(%rip), %rsi      # 0x17690
callq 0x50f0
testl %eax, %eax
je 0x11715
leaq 0x5fed(%rip), %rsi      # 0x17697
movq %rbx, %rdi
callq 0x50f0
testl %eax, %eax
je 0x1171c
leaq 0x5fe5(%rip), %rsi      # 0x176a2
movq %rbx, %rdi
callq 0x50f0
testl %eax, %eax
je 0x11723
leaq 0x5fdf(%rip), %rsi      # 0x176af
movq %rbx, %rdi
callq 0x50f0
movl %eax, %ecx
movl $0x8, %eax
testl %ecx, %ecx
je 0x11728
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x5fc4(%rip), %rsi      # 0x176bb
movq %rax, %rdi
callq 0x5650
movq 0xe8c2(%rip), %rsi      # 0x1ffc8
movq 0xe89b(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55d0
movl $0x1, %eax
jmp 0x11728
movl $0x2, %eax
jmp 0x11728
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::MaliciousBehaviorString[abi:cxx11](generals::MaliciousBehavior)
std::string MaliciousBehaviorString(MaliciousBehavior m) {
  switch (m) {
    case MaliciousBehavior::SILENT:
      return "silent";
    case MaliciousBehavior::DELAY_SEND:
      return "delay_send";
    case MaliciousBehavior::PARTIAL_SEND:
      return "partial_send";
    case MaliciousBehavior::WRONG_ORDER:
      return "wrong_order";
    default:
      throw std::invalid_argument("unexpected MaliciousBehavior value");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
decl %esi
cmpl $0x7, %esi
ja 0x117d2
movq %rdi, %rbx
leaq 0x5cd4(%rip), %rax      # 0x17430
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5f1d(%rip), %rsi      # 0x17690
leaq 0x5f1c(%rip), %rdx      # 0x17696
jmp 0x117bf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5f18(%rip), %rsi      # 0x176a2
leaq 0x5f1d(%rip), %rdx      # 0x176ae
jmp 0x117bf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5f0e(%rip), %rsi      # 0x176af
leaq 0x5f12(%rip), %rdx      # 0x176ba
jmp 0x117bf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5edf(%rip), %rsi      # 0x17697
leaq 0x5ee2(%rip), %rdx      # 0x176a1
movq %rbx, %rdi
callq 0xe30c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x5f2b(%rip), %rsi      # 0x17711
movq %rax, %rdi
callq 0x5650
movq 0xe7d3(%rip), %rsi      # 0x1ffc8
movq 0xe7ac(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Commander::OrderForMsg() const
msg::Order Commander::OrderForMsg() const {
  if (ExhibitsBehavior(MaliciousBehavior::WRONG_ORDER)) {
    // Send wrong order 30% of the time.
    static thread_local std::default_random_engine random_engine(
        std::chrono::system_clock::now().time_since_epoch().count());

    std::uniform_real_distribution<double> distribution(0.0, 1.0);
    if (distribution(random_engine) < 0.30) {
      return order_ == msg::Order::ATTACK ? msg::Order::RETREAT
                                          : msg::Order::ATTACK;
    }
  }
  return order_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x8, 0x60(%rdi)
jne 0x11d5d
movl 0x68(%rbx), %eax
jmp 0x11d9a
cmpb $0x0, %fs:-0x8
je 0x11d9c
movq %fs:0x0, %rax
leaq -0x10(%rax), %rdi
callq 0x13d9d
movl 0x68(%rbx), %eax
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %dl
movsd 0x5870(%rip), %xmm1     # 0x17600
ucomisd %xmm0, %xmm1
jbe 0x11d9a
movb %dl, %cl
movl %ecx, %eax
popq %rbx
retq
callq 0x5767
jmp 0x11d68
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Lieutenant::ContinueUnlessTimeout()
udp::ServerAction Lieutenant::ContinueUnlessTimeout() {
  // Compute the duration between the start of the round and now.
  const auto now = std::chrono::steady_clock::now();
  const auto round_dur = std::chrono::duration_cast<std::chrono::microseconds>(
      now - round_start_ts_);

  // If this duration is more than the round timeout, handle the timeout.
  if (round_dur > kRoundTimeout) {
    HandleRoundTimeout();
  }
  return udp::ServerAction::Continue;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5460
subq 0xa0(%rbx), %rax
cmpq $0x3b9acde8, %rax       # imm = 0x3B9ACDE8
jl 0x11f08
movq %rbx, %rdi
callq 0x11f0c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Lieutenant::MoveToNewRoundOrStop()
udp::ServerAction Lieutenant::MoveToNewRoundOrStop() {
  if (LastRound()) {
    ClearSenders();
    return udp::ServerAction::Stop;
  }
  InitNewRound();
  return udp::ServerAction::Continue;
}

// Assembly:
pushq %rax
movl 0x5c(%rdi), %eax
incl %eax
cmpl %eax, 0x64(%rdi)
jne 0x11f79
callq 0x11f82
movl $0x1, %eax
jmp 0x11f80
callq 0x11fec
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/bowenfan96[P]icl-mcs-enigma/main.cpp
// Function: main
int main(int argc, char** argv) 
{
    try {
        Enigma en(argc, argv);
        
        char input;
        while(std::cin >> std::ws >> input) {
            std::cout << en.encryptor(input) << std::flush;
        }
    }
    
    catch(int error) {
        return error;
    }
    
    return(NO_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq -0x78(%rbp), %rdi
callq 0x3c42
movq 0x6b26(%rip), %rbx      # 0x8fd8
leaq -0x29(%rbp), %r14
leaq -0x78(%rbp), %r15
movq 0x6b07(%rip), %r12      # 0x8fc8
leaq -0x2a(%rbp), %r13
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x250f
movsbl -0x29(%rbp), %esi
movq %r15, %rdi
callq 0x450a
movb %al, -0x2a(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
jmp 0x24c5
leaq -0x78(%rbp), %rdi
callq 0x4766
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x2542
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4766
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x2559
callq 0x20a0
movl (%rax), %ebx
callq 0x2280
jmp 0x251a
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::is_valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Enigma::is_valid(const std::string& index) 
{
    size_t sz;
    int num = std::stoi(index, &sz);
    if(num < 0 || num > 25) {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
callq 0x2030
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2210
cmpq %r14, (%r15)
je 0x2bfb
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x2c07
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x2c07
testl %ecx, %ecx
jne 0x2be8
movl %r12d, (%rbx)
cmpl $0x1a, %eax
setb %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3841(%rip), %rdi      # 0x6443
callq 0x20f0
leaq 0x3835(%rip), %rdi      # 0x6443
callq 0x2220
cmpl $0x0, (%rbx)
jne 0x2c1b
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::is_one_to_one(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
bool Enigma::is_one_to_one(const std::vector<int>& map_from, const std::vector<int>& map_to) 
{
    // check if both arrays contain only unique elements
    int sz = map_to.size();
    
    std::unordered_set<int> set1;
    for(int i=0; i < sz; i++) {
        if(!set1.insert(map_from[i]).second) {
            return false;
        }
    }
    std::unordered_set<int> set2;
    for(int i=0; i < sz; i++) {
        if(!set2.insert(map_to[i]).second) {
            return false;
        }
    }
    
    // check if an index maps to itself
    for(int i=0; i < sz; i++) {
        if(map_from.at(i) == map_to.at(i)) {
            return false;
        }
    }
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %rcx
movq %rsi, -0x38(%rbp)
subq (%rsi), %rcx
shrq $0x2, %rcx
leaq -0x88(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq %rcx, -0x30(%rbp)
testl %ecx, %ecx
jle 0x2cb6
movq -0x30(%rbp), %r13
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebx, %ebx
leaq -0xb8(%rbp), %r15
leaq -0x80(%rbp), %r12
movq (%r14), %rsi
addq %rbx, %rsi
movq %r15, -0x80(%rbp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x4d50
testb $0x1, %dl
je 0x2d7c
addq $0x4, %rbx
decq %r13
jne 0x2c8f
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq -0x30(%rbp), %rax
testl %eax, %eax
jle 0x2d80
movl %eax, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebx, %ebx
leaq -0x80(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r13, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
addq %rbx, %rsi
movq %r15, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x4d50
testb $0x1, %dl
je 0x2d78
addq $0x4, %rbx
decq %r13
jne 0x2cfc
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq -0x38(%rbp), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
movq -0x30(%rbp), %r9
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
xorl %edi, %edi
movq -0x40(%rbp), %r10
cmpq %rdi, %rdx
je 0x2dae
cmpq %rdi, %rcx
je 0x2dab
movl (%rax,%rdi,4), %r8d
cmpl (%rsi,%rdi,4), %r8d
je 0x2d78
incq %rdi
cmpq %rdi, %r10
jne 0x2d54
cmpq %r9, %rdi
setae %bl
jmp 0x2d82
xorl %ebx, %ebx
jmp 0x2d82
xorl %ebx, %ebx
jmp 0x2d8b
movb $0x1, %bl
leaq -0x80(%rbp), %rdi
callq 0x491a
leaq -0xb8(%rbp), %rdi
callq 0x491a
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rdx
leaq 0x36c5(%rip), %rdi      # 0x647a
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2240
jmp 0x2dc1
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x491a
jmp 0x2dd2
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x491a
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::Plugboard::mapper(int)
int Enigma::Plugboard::mapper(int input) 
{
    auto iter = std::find(map_from.cbegin(), map_from.cend(), input);
    
    if(iter != map_from.cend()) {
        int index = std::distance(map_from.cbegin(), iter);
        return map_to.at(index);
    }
    else {
        return input;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x14(%rbp), %r14
movl %esi, (%r14)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x4ca2
cmpq 0x8(%rbx), %rax
je 0x2e32
subq (%rbx), %rax
shrq $0x2, %rax
movslq %eax, %rsi
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x2e3e
leaq (%rax,%rsi,4), %r14
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3635(%rip), %rdi      # 0x647a
xorl %eax, %eax
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::Rotor::rotate()
void Enigma::Rotor::rotate() 
{
    position = (position + 1) % 26;
    
    if(std::find(triggers.cbegin(), triggers.cend(), position) != triggers.cend()) {
        triggered = true;
    }
    else {
        triggered = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe8(%rdi), %rdx
movl 0xe8(%rdi), %eax
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
imulq $0x4ec4ec4f, %rcx, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rsi
shrq $0x3f, %rsi
sarq $0x23, %rcx
addl %esi, %ecx
leal (%rcx,%rcx,4), %esi
leal (%rsi,%rsi,4), %esi
addl %ecx, %esi
negl %esi
addl %esi, %eax
incl %eax
movl %eax, 0xe8(%rdi)
movq 0xd0(%rdi), %rdi
movq 0xd8(%rbx), %rsi
callq 0x4ca2
cmpq 0xd8(%rbx), %rax
setne 0xec(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::turn_rotors()
void Enigma::turn_rotors() 
{
    for(auto rot = vec_rotors.rbegin(); rot != vec_rotors.rend(); ++rot) {
        
        if(rot == vec_rotors.rbegin()) {
            rot->rotate();
        }
        else if ((rot-1)->triggered) {
            rot->rotate();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
cmpq 0x8(%rdi), %r14
je 0x4761
movq %rdi, %rbx
cmpq 0x10(%rbx), %r14
je 0x470a
cmpb $0x1, 0xec(%r14)
jne 0x4754
leaq -0x8(%r14), %rdx
movl -0x8(%r14), %eax
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
imulq $0x4ec4ec4f, %rcx, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rsi
shrq $0x3f, %rsi
sarq $0x23, %rcx
addl %esi, %ecx
leal (%rcx,%rcx,4), %esi
leal (%rsi,%rsi,4), %esi
addl %ecx, %esi
negl %esi
addl %esi, %eax
incl %eax
movl %eax, -0x8(%r14)
movq -0x20(%r14), %rdi
movq -0x18(%r14), %rsi
callq 0x4ca2
cmpq -0x18(%r14), %rax
setne -0x4(%r14)
addq $-0xf0, %r14
cmpq 0x8(%rbx), %r14
jne 0x46fa
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shreyas-gopalakrishna[P]Concurrent-Skip-list/main.cpp
// Function: skiplist_range(int, int)
void skiplist_range(int start, int end){
    map<int, string> range_output = skiplist.range(start, end);

    string s = "";
    for (auto const& x : range_output){
        s += x.second + " ";
    }
    cout << "Range (" << start << ", " << end << ") = " << s << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ecx
movl %edi, %edx
leaq 0x85e1(%rip), %rsi      # 0xb290
leaq 0x48(%rsp), %rdi
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
callq 0x58f8
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x4379(%rip), %rdx      # 0x7049
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x4536
leaq 0x50(%rsp), %rbp
movq 0x10(%rbp), %r14
cmpq %rbp, %r14
je 0x2d5d
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r15
leaq 0x4b21(%rip), %r12      # 0x781d
leaq 0x28(%rsp), %r13
movq %rbx, 0x8(%rsp)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x41e6
movq %r15, %rdi
movq %r12, %rsi
callq 0x2380
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2d4d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
cmpq %rbp, %rax
jne 0x2d01
movq 0x826c(%rip), %rdi      # 0xafd0
leaq 0x467a(%rip), %rsi      # 0x73e5
movl $0x7, %edx
callq 0x2250
movq 0x8254(%rip), %rdi      # 0xafd0
movl 0x4(%rsp), %esi
callq 0x2340
movq %rax, %r14
leaq 0x465e(%rip), %rsi      # 0x73ed
movl $0x2, %edx
movq %rax, %rdi
callq 0x2250
movq %r14, %rdi
movl (%rsp), %esi
callq 0x2340
movq %rax, %rbx
leaq 0x463f(%rip), %rsi      # 0x73f0
movl $0x4, %edx
movq %rax, %rdi
callq 0x2250
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2e16
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x48(%rsp), %rdi
callq 0x4164
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2e73
jmp 0x2e36
movq %rax, %r14
jmp 0x2e57
jmp 0x2e3d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2e57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2e73
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x48(%rsp), %rdi
callq 0x4164
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/MultiSwitchArg.h
// Function: TCLAP::MultiSwitchArg::processArg(int*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
{
	if ( _ignoreable && Arg::ignoreRest() )
		return false;

	if ( argMatches( args[*i] ))
	{
		// so the isSet() method will work
		_alreadySet = true;

		// Matched argument: increment value.
		++_value;

		_checkWithVisitor();

		return true;
	}
	else if ( combinedSwitchesMatch( args[*i] ) )
	{
		// so the isSet() method will work
		_alreadySet = true;

		// Matched argument: increment value.
		++_value;

		// Check for more in argument and increment value.
		while ( combinedSwitchesMatch( args[*i] ) ) 
			++_value;

		_checkWithVisitor();

		return false;
	}
	else
		return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpb $0x1, 0xa0(%rdi)
jne 0x49ad
cmpb $0x0, 0xc813(%rip)      # 0x111ba
jne 0x4a37
movslq (%r12), %rsi
shlq $0x5, %rsi
addq (%r15), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movl %eax, %ebx
testb %al, %al
je 0x49e6
movb $0x1, 0x91(%r14)
incl 0xa8(%r14)
movq 0x98(%r14), %rdi
testq %rdi, %rdi
jne 0x4a2f
movb $0x1, %bl
jmp 0x4a39
movslq (%r12), %rsi
shlq $0x5, %rsi
addq (%r15), %rsi
movq %r14, %rdi
callq 0x4348
testb %al, %al
je 0x4a37
movb $0x1, 0x91(%r14)
incl 0xa8(%r14)
movslq (%r12), %rsi
shlq $0x5, %rsi
addq (%r15), %rsi
movq %r14, %rdi
callq 0x4348
testb %al, %al
jne 0x4a05
movq 0x98(%r14), %rdi
testq %rdi, %rdi
je 0x4a37
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x4a39
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: id::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void id::display(string s){
    if(argc == 3){
        outfile << left << setw(30) << "Identifier" << left << setw(30) << s << endl;
    }else{
        cout << left << setw(30) << "Identifier" << left << setw(30) << s << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x5db9(%rip), %rax      # 0xa1ac
cmpl $0x3, (%rax)
jne 0x4401
leaq 0x5db9(%rip), %r14      # 0xa1b8
jmp 0x4408
movq 0x5bc0(%rip), %r14      # 0x9fc8
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %r15d      # imm = 0xFFFFFF4F
movl 0x18(%r14,%rcx), %edx
andl %r15d, %edx
orl $0x20, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movl $0x1e, %r12d
movq %r12, 0x10(%r14,%rax)
leaq 0x1c09(%rip), %rsi      # 0x6044
movl $0xa, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rcx
andl 0x18(%r14,%rcx), %r15d
orl $0x20, %r15d
movl %r15d, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movq %r12, 0x10(%r14,%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: id::detected()
int id::detected(){
    string s(yytext);
    if(exit(s)){
        inc_id_cnt();
        display(s);
        return wordlist[s];
    }else{
        add_id(s);
        display(s);
        return id_id - 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
leaq 0x5f03(%rip), %rax      # 0xa3e0
movq (%rax), %rsi
leaq -0x38(%rbp), %rbx
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x5786
leaq -0xa8(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0xb8(%rbp), %rdi
callq 0x5862
leaq 0x5f28(%rip), %rdi      # 0xa440
leaq -0xb8(%rbp), %rsi
callq 0x5c6e
movq %rax, %rbx
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x4542
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2170
leaq 0x5eff(%rip), %rax      # 0xa448
cmpq %rax, %rbx
je 0x45ba
incl 0x5ee4(%rip)            # 0xa438
incl 0x5eda(%rip)            # 0xa434
leaq -0x88(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x5862
leaq -0x98(%rbp), %rsi
callq 0x43de
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0x45a3
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2170
leaq 0x5e96(%rip), %rdi      # 0xa440
leaq -0x38(%rbp), %rsi
callq 0x5706
movl (%rax), %ebx
jmp 0x464b
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x5862
movl 0x5bb0(%rip), %ebx      # 0xa18c
leaq 0x5e5d(%rip), %rdi      # 0xa440
leaq -0x78(%rbp), %rsi
callq 0x5706
movl %ebx, (%rax)
incl 0x5b98(%rip)            # 0xa18c
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x4609
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2170
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x5862
leaq -0x58(%rbp), %rsi
callq 0x43de
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x4643
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2170
movl 0x5b43(%rip), %ebx      # 0xa18c
decl %ebx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4664
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2170
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x46d1
movq -0x48(%rbp), %rsi
jmp 0x46c4
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x46d1
movq -0x68(%rbp), %rsi
jmp 0x46c4
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0x46d1
movq -0x88(%rbp), %rsi
jmp 0x46c4
movq %rax, %rbx
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x46d1
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2170
jmp 0x46d1
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46ea
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0