LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::set_deleted_key(unsigned int const&)
void set_deleted_key(const key_type &key) {
    // the empty indicator (if specified) and the deleted indicator
    // must be different
    assert((!settings.use_empty() || !equals(key, get_key(val_info.emptyval)))
           && "Passed the empty-key to set_deleted_key");
    // It's only safe to change what "deleted" means if we purge deleted guys
    squash_deleted();
    settings.set_use_deleted(true);
    key_info.delkey = key;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x19(%rdi)
jne 0x19c8
movl (%r14), %eax
cmpl 0x40(%rbx), %eax
je 0x19e2
movq %rbx, %rdi
callq 0x1a02
movb $0x1, 0x1a(%rbx)
movl (%r14), %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ad4(%rip), %rdi      # 0x34bd
leaq 0x172b(%rip), %rsi      # 0x311b
leaq 0x1b37(%rip), %rcx      # 0x352e
movl $0x18a, %edx            # imm = 0x18A
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::squash_deleted()
void squash_deleted() {           // gets rid of any deleted entries we have
    if ( num_deleted ) {            // get rid of deleted before writing
      dense_hashtable tmp(*this);   // copying will get rid of deleted
      swap(tmp);                    // now we are tmp
    }
    assert(num_deleted == 0);
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1a49
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x20, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a8a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1be0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1a42
callq 0x10a0
cmpq $0x0, 0x28(%rbx)
jne 0x1a51
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x2e39(%rip), %rdi      # 0x4891
leaq 0x16bc(%rip), %rsi      # 0x311b
leaq 0x1dc4(%rip), %rcx      # 0x382a
movl $0x17a, %edx            # imm = 0x17A
callq 0x1070
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1a82
callq 0x10a0
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::clear_to_size(unsigned long)
void clear_to_size(size_type new_num_buckets) {
    if (!table) {
      table = val_info.allocate(new_num_buckets);
    } else {
      destroy_buckets(0, num_buckets);
      if (new_num_buckets != num_buckets) {   // resize, if necessary
        typedef base::integral_constant<bool,
            base::is_same<value_alloc_type,
                          libc_allocator_with_realloc<value_type> >::value>
            realloc_ok;
        resize_table(num_buckets, new_num_buckets, realloc_ok());
      }
    }
    assert(table);
    fill_range_with_empty(table, table + new_num_buckets);
    num_elements = 0;
    num_deleted = 0;
    num_buckets = new_num_buckets;          // our new size
    settings.reset_thresholds(bucket_count());
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1f2a
cmpq %r14, 0x38(%rbx)
je 0x1f44
leaq 0x40(%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2056
jmp 0x1f37
leaq (,%r14,8), %rdi
callq 0x10d0
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x1ff6
testq %r14, %r14
je 0x1f64
leaq (,%r14,8), %rcx
xorl %edx, %edx
movq 0x40(%rbx), %rsi
movq %rsi, (%rax,%rdx)
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x1f53
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %r14, 0x38(%rbx)
testq %r14, %r14
js 0x1f7e
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
jmp 0x1f97
movq %r14, %rax
shrq %rax
andl $0x1, %r14d
orq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
addss %xmm0, %xmm0
movss 0x10(%rbx), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movss 0x109c(%rip), %xmm2     # 0x3050
subss %xmm2, %xmm1
cvttss2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, (%rbx)
mulss 0x14(%rbx), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss %xmm2, %xmm0
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x8(%rbx)
movb $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14ba(%rip), %rdi      # 0x34b7
leaq 0x1117(%rip), %rsi      # 0x311b
leaq 0x221b(%rip), %rcx      # 0x4226
movl $0x314, %edx            # imm = 0x314
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: std::pair<unsigned int const, unsigned int>& google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::find_or_insert<google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::DefaultValue>(unsigned int const&)
value_type& find_or_insert(const key_type& key) {
    // First, double-check we're not inserting emptykey or delkey
    assert((!settings.use_empty() || !equals(key, get_key(val_info.emptyval)))
           && "Inserting the empty key");
    assert((!settings.use_deleted() || !equals(key, key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(key);
    DefaultValue default_value;
    if ( pos.first != ILLEGAL_BUCKET) {  // object was already there
      return table[pos.first];
    } else if (resize_delta(1)) {        // needed to rehash to make room
      // Since we resized, we can't use pos, so recalculate where to insert.
      return *insert_noresize(default_value(key)).first;
    } else {                             // no need to rehash, insert right here
      return *insert_at(default_value(key), pos.second);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x19(%rdi)
jne 0x2151
movl (%r14), %eax
cmpl 0x40(%rbx), %eax
je 0x21db
cmpb $0x0, 0x1a(%rbx)
je 0x2163
movl (%r14), %eax
cmpl 0x20(%rbx), %eax
je 0x21fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x221a
cmpq $-0x1, %rax
je 0x217e
shlq $0x3, %rax
addq 0x48(%rbx), %rax
jmp 0x21d1
movq %rdx, %r15
movl $0x1, %esi
movq %rbx, %rdi
callq 0x22fa
testb %al, %al
je 0x21af
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x248a
jmp 0x21cd
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2544
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2fba(%rip), %rdi      # 0x519c
leaq 0xf32(%rip), %rsi       # 0x311b
leaq 0x300d(%rip), %rcx      # 0x51fd
movl $0x3df, %edx            # imm = 0x3DF
callq 0x1070
leaq 0x3357(%rip), %rdi      # 0x5558
leaq 0xf13(%rip), %rsi       # 0x311b
leaq 0x2fee(%rip), %rcx      # 0x51fd
movl $0x3e1, %edx            # imm = 0x3E1
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::find_position(unsigned int const&) const
std::pair<size_type, size_type> find_position(const key_type &key) const {
    size_type num_probes = 0;              // how many times we've probed
    const size_type bucket_count_minus_one = bucket_count() - 1;
    size_type bucknum = hash(key) & bucket_count_minus_one;
    size_type insert_pos = ILLEGAL_BUCKET; // where we would insert
    while ( 1 ) {                          // probe until something happens
      if ( test_empty(bucknum) ) {         // bucket is empty
        if ( insert_pos == ILLEGAL_BUCKET )   // found no prior place to insert
          return std::pair<size_type,size_type>(ILLEGAL_BUCKET, bucknum);
        else
          return std::pair<size_type,size_type>(ILLEGAL_BUCKET, insert_pos);

      } else if ( test_deleted(bucknum) ) {// keep searching, but mark to insert
        if ( insert_pos == ILLEGAL_BUCKET )
          insert_pos = bucknum;

      } else if ( equals(key, get_key(table[bucknum])) ) {
        return std::pair<size_type,size_type>(bucknum, ILLEGAL_BUCKET);
      }
      ++num_probes;                        // we're doing another probe
      bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
      assert(num_probes < bucket_count()
             && "Hashtable is full: an error in key_equal<> or hash<>");
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rdi), %r12
decq %r12
movl (%rsi), %ebx
andl %r12d, %ebx
movq $-0x1, %r13
xorl %ebp, %ebp
cmpb $0x0, 0x19(%r15)
je 0x22db
movq 0x48(%r15), %rax
movl 0x40(%r15), %ecx
cmpl (%rax,%rbx,8), %ecx
je 0x22ae
movq %r15, %rdi
movq %rbx, %rsi
callq 0x265c
testb %al, %al
je 0x2271
cmpq $-0x1, %r13
cmoveq %rbx, %r13
jmp 0x227d
movq 0x48(%r15), %rax
movl (%r14), %ecx
cmpl (%rax,%rbx,8), %ecx
je 0x22c2
addq %rbp, %rbx
incq %rbx
incq %rbp
andq %r12, %rbx
cmpq 0x38(%r15), %rbp
jb 0x2240
leaq 0x1f3a(%rip), %rdi      # 0x41d0
leaq 0xe7e(%rip), %rsi       # 0x311b
leaq 0x330e(%rip), %rcx      # 0x55b2
movl $0x354, %edx            # imm = 0x354
callq 0x1070
cmpq $-0x1, %r13
cmovneq %r13, %rbx
movq %rbx, %rdx
movq $-0x1, %rbx
jmp 0x22c9
movq $-0x1, %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x227d(%rip), %rdi      # 0x455f
leaq 0xe32(%rip), %rsi       # 0x311b
leaq 0x28c7(%rip), %rcx      # 0x4bb7
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_noresize(std::pair<unsigned int const, unsigned int> const&)
std::pair<iterator, bool> insert_noresize(const_reference obj) {
    // First, double-check we're not inserting delkey or emptyval
    assert((!settings.use_empty() || !equals(get_key(obj),
                                             get_key(val_info.emptyval)))
           && "Inserting the empty key");
    assert((!settings.use_deleted() || !equals(get_key(obj), key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(get_key(obj));
    if ( pos.first != ILLEGAL_BUCKET) {      // object was already there
      return std::pair<iterator,bool>(iterator(this, table + pos.first,
                                          table + num_buckets, false),
                                 false);          // false: we didn't insert
    } else {                                 // pos.second says where to put it
      return std::pair<iterator,bool>(insert_at(obj, pos.second), true);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x19(%rsi)
jne 0x24a7
movl (%r15), %eax
cmpl 0x40(%r14), %eax
je 0x2506
cmpb $0x0, 0x1a(%r14)
je 0x24b7
movl (%r15), %eax
cmpl 0x20(%r14), %eax
je 0x2525
movq %r14, %rdi
movq %r15, %rsi
callq 0x221a
cmpq $-0x1, %rax
je 0x24e7
movq 0x38(%r14), %rcx
movq 0x48(%r14), %rdx
leaq (%rdx,%rax,8), %rax
leaq (%rdx,%rcx,8), %rcx
movq %r14, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
xorl %eax, %eax
jmp 0x24fa
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2544
movb $0x1, %al
movb %al, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x39de(%rip), %rdi      # 0x5eeb
leaq 0xc07(%rip), %rsi       # 0x311b
leaq 0x3a3a(%rip), %rcx      # 0x5f55
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x1070
leaq 0x3d39(%rip), %rdi      # 0x6265
leaq 0xbe8(%rip), %rsi       # 0x311b
leaq 0x3a1b(%rip), %rcx      # 0x5f55
movl $0x3aa, %edx            # imm = 0x3AA
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_at(std::pair<unsigned int const, unsigned int> const&, unsigned long)
iterator insert_at(const_reference obj, size_type pos) {
    if (size() >= max_size()) {
      throw std::length_error("insert overflow");
    }
    if ( test_deleted(pos) ) {      // just replace if it's been del.
      // shrug: shouldn't need to be const.
      const_iterator delpos(this, table + pos, table + num_buckets, false);
      clear_deleted(delpos);
      assert( num_deleted > 0);
      --num_deleted;                // used to be, now it isn't
    } else {
      ++num_elements;               // replacing an empty bucket
    }
    set_value(&table[pos], obj);
    return iterator(this, table + pos, table + num_buckets, false);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq 0x30(%rsi), %rax
subq 0x28(%rsi), %rax
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jae 0x25f7
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x265c
testb %al, %al
je 0x25bd
movq 0x38(%r14), %rax
movq 0x48(%r14), %rcx
leaq (%rcx,%r15,8), %rdx
leaq (%rcx,%rax,8), %rax
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x27e0
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x2629
decq %rax
movq %rax, 0x28(%r14)
jmp 0x25c1
incq 0x30(%r14)
movq 0x48(%r14), %rax
movq (%r12), %rcx
movq %rcx, (%rax,%r15,8)
movq 0x38(%r14), %rax
movq 0x48(%r14), %rcx
leaq (%rcx,%r15,8), %rdx
leaq (%rcx,%rax,8), %rax
movq %r14, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1050
movq %rax, %rbx
leaq 0x3cbd(%rip), %rsi      # 0x62c8
movq %rax, %rdi
callq 0x1090
movq 0x69c6(%rip), %rsi      # 0x8fe0
movq 0x69af(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x1110
leaq 0x2577(%rip), %rdi      # 0x4ba7
leaq 0xae4(%rip), %rsi       # 0x311b
leaq 0x3c9a(%rip), %rcx      # 0x62d8
movl $0x39a, %edx            # imm = 0x39A
callq 0x1070
movq %rax, %r14
movq %rbx, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O3/KokiKishimoto[P]cp_decomposition/add_rev.cpp
// Function: AddRev::add_rev()
void add_rev(void){
		std::vector<std::string> tmp(3);
		std::string l, m, n;
		int triplesize = triple.size();
		for(int i=0; i<triplesize; i++){
			tmp[0] = triple[i][2];
			tmp[1] = "**" + triple[i][1];
			tmp[2] = triple[i][0];
	
			triple.push_back(tmp);
	
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
movl $0x3, %esi
callq 0x2e28
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
testl %ebp, %ebp
jle 0x2970
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x1809(%rip), %r14      # 0x40c3
leaq 0x78(%rsp), %r15
movq %rsp, %r12
movq (%rbx), %rax
movq (%rax,%r13), %rsi
addq $0x40, %rsi
movq (%rsp), %rdi
callq 0x2110
movq (%rbx), %rax
movq (%rax,%r13), %rdx
addq $0x20, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3469
movq (%rsp), %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x291e
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rbx), %rax
movq (%rax,%r13), %rsi
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2eb4
addq $0x18, %r13
decq %rbp
jne 0x28c2
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
leaq 0x28(%rsp), %r14
leaq 0x68(%rsp), %r15
je 0x2970
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2987
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x299e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rsp, %rdi
callq 0x2f7a
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29ba
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x29d9
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x29f5
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2a11
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rsp, %rdi
callq 0x2f7a
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/KokiKishimoto[P]cp_decomposition/add_rev.cpp
// Function: AddRev::load[abi:cxx11]()
std::vector< std::vector <std::string> > load(void){
		std::fstream fs;
		std::vector<std::string> tmp(3);
		std::string l,m,n;
		fs.open(triple_file, std::ios::in);
		while (fs >> l >> m >> n){
			tmp[0] = l;
			tmp[1] = m;
			tmp[2] = n;
			
			triple.push_back(tmp);
		}
		
		fs.close(); 
		return triple;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x21f0
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x3, %esi
callq 0x2e28
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x58(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x18(%r14), %rsi
leaq 0x88(%rsp), %rdi
movl $0x8, %edx
callq 0x2230
movq %rbx, 0x40(%rsp)
leaq 0x88(%rsp), %r15
leaq 0x20(%rsp), %r12
leaq 0x68(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2cc5
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2110
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq %r13, %rsi
callq 0x2110
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq %rbp, %rsi
callq 0x2110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eb4
jmp 0x2c5a
leaq 0x88(%rsp), %rdi
callq 0x2040
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ee0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2cfe
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2d1a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2d36
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x8(%rsp), %rdi
callq 0x2f7a
leaq 0x88(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2dca
jmp 0x2d69
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2d88
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2da4
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2dc0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x8(%rsp), %rdi
callq 0x2f7a
leaq 0x88(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: parent_signals()
void parent_signals() {
  if(signal(SIGINT, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGQUIT, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGTSTP, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGTTIN, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGTTOU, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGPIPE, SIG_IGN) == SIG_ERR) nope_out("signal");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %esi
movl $0x2, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x575c
movl $0x1, %esi
movl $0x3, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5765
movl $0x1, %esi
movl $0x14, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x576e
movl $0x1, %esi
movl $0x15, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5777
movl $0x1, %esi
movl $0x16, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5780
movl $0x1, %esi
movl $0xd, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5789
addq $0x20, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x369f
leaq -0x20(%rbp), %rdi
callq 0x366c
leaq -0x20(%rbp), %rdi
callq 0x3639
leaq -0x20(%rbp), %rdi
callq 0x3606
leaq -0x20(%rbp), %rdi
callq 0x35d3
leaq -0x20(%rbp), %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: chdir_home()
void chdir_home() {
  // home dir retrieval
  const char * homedir = nullptr;
  string s_homedir = "";
  if((homedir = getenv("HOME")) == nullptr) {
    homedir = getpwuid(getuid())->pw_dir;
  } // if
  s_homedir = string(homedir);
  chdir(homedir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x9364(%rip), %rdx      # 0xeb12
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x9ff0
leaq 0x7883(%rip), %rdi      # 0xd044
callq 0x3340
movq %rax, %rbx
testq %rax, %rax
jne 0x57de
callq 0x3150
movl %eax, %edi
callq 0x3310
movq 0x20(%rax), %rbx
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rbx, %rsi
callq 0x3110
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %r14
movq %r14, %rsi
callq 0x3350
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x5816
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3420
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5833
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x32c0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5840
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5858
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: hasEvenQuotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool hasEvenQuotes(string input) {
  int count = 0;
  for(unsigned int i = 0; i < input.length(); i++) {
    if(i == 0) {
      if(input[i] == '"') count++;
    } else {
      if(input[i] == '"' && input[i-1] != '\\') count++;
    } // if/else
  } // for
  if(count % 2 == 0) { 
    return true;
  } else {
    return false;
  } // if/else
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x6095
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %ecx, %ecx
movl $0x1, %esi
movq %rdx, %rdi
movb (%rdi), %r8b
cmpl $0x1, %esi
jne 0x6067
xorl %r9d, %r9d
cmpb $0x22, %r8b
sete %r9b
jmp 0x607d
cmpb $0x22, %r8b
jne 0x6080
leal -0x2(%rsi), %r8d
xorl %r9d, %r9d
cmpb $0x5c, (%rdx,%r8)
setne %r9b
addl %r9d, %ecx
movl %esi, %r8d
incq %rdi
incl %esi
cmpq %r8, %rax
ja 0x6052
testb $0x1, %cl
sete %al
popq %rbp
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: makePipes(int)
int** makePipes(int numPipes) {
  int** pipes = nullptr;
  if(numPipes != 0) {
    pipes = new int * [numPipes];
    for(int i = 0; i < numPipes; i++) {
      pipes[i] = new int[2];
    } // for
  } // if
  return pipes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x60e9
movl %edi, %r14d
movl %edi, %r15d
leaq (,%r15,8), %rax
testl %edi, %edi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %rbx
testl %r14d, %r14d
jle 0x60eb
xorl %r14d, %r14d
movl $0x8, %edi
callq 0x3030
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq %r14, %r15
jne 0x60d1
jmp 0x60eb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: isBuiltIn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool isBuiltIn(string & command) {
  bool isBuiltIn = false;
  if(command == "cd") {
    isBuiltIn = true;
  } else if(command == "exit") {
    isBuiltIn = true;
  } else if(command == "help") {
    isBuiltIn = true;
  } else if(command == "bg") {
    isBuiltIn = true;
  } else if(command == "fg") {
    isBuiltIn = true;
  } else if(command == "export") {
    isBuiltIn = true;
  } else if(command == "jobs") {
    isBuiltIn = true;
  } else if(command == "kill") {
    isBuiltIn = true;
  } // if/else
  return isBuiltIn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x79c0(%rip), %rsi      # 0xe144
callq 0x30b0
movb $0x1, %bl
testl %eax, %eax
je 0x6819
leaq 0x79ad(%rip), %rsi      # 0xe147
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6819
leaq 0x7a06(%rip), %rsi      # 0xe1b3
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6819
leaq 0x798c(%rip), %rsi      # 0xe14c
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6819
leaq 0x797c(%rip), %rsi      # 0xe14f
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6819
leaq 0x796c(%rip), %rsi      # 0xe152
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6819
leaq 0x819b(%rip), %rsi      # 0xe994
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6819
leaq 0x794d(%rip), %rsi      # 0xe159
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: do_redirects(int, int, int)
void do_redirects(int STDIN, int STDOUT, int STDERR) {
  if(STDIN >= 0) {
    if(dup2(STDIN, STDIN_FILENO) == -1) nope_out("dup2");
  } // if
  if(STDOUT >= 0) {
    if(dup2(STDOUT, STDOUT_FILENO) == -1) nope_out("dup2");
  } // if
  if(STDERR >= 0) {
    if(dup2(STDERR, STDERR_FILENO) == -1) nope_out("dup2");
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %r14d
testl %edi, %edi
js 0x6840
xorl %esi, %esi
callq 0x3270
cmpl $-0x1, %eax
je 0x6875
testl %r14d, %r14d
js 0x6857
movl %r14d, %edi
movl $0x1, %esi
callq 0x3270
cmpl $-0x1, %eax
je 0x687e
testl %ebx, %ebx
js 0x686c
movl %ebx, %edi
movl $0x2, %esi
callq 0x3270
cmpl $-0x1, %eax
je 0x6887
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x374c
leaq -0x30(%rbp), %rdi
callq 0x3719
leaq -0x30(%rbp), %rdi
callq 0x36e6
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: close_redirects(int, int, int)
void close_redirects(int STDIN, int STDOUT, int STDERR) {
  if(STDIN != STDIN_FILENO) {
    if(close(STDIN) == -1) nope_out("close");
  } // if
  if(STDOUT != STDOUT_FILENO) {
    if(close(STDOUT) == -1) nope_out("close");
  } // if
  if(STDERR != STDERR_FILENO) {
    if(close(STDERR) == -1) nope_out("close");
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %r14d
testl %edi, %edi
je 0x68ae
callq 0x3580
cmpl $-0x1, %eax
je 0x68db
cmpl $0x1, %r14d
je 0x68c1
movl %r14d, %edi
callq 0x3580
cmpl $-0x1, %eax
je 0x68e4
cmpl $0x2, %ebx
je 0x68d2
movl %ebx, %edi
callq 0x3580
cmpl $-0x1, %eax
je 0x68ed
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x377f
leaq -0x30(%rbp), %rdi
callq 0x37b2
leaq -0x30(%rbp), %rdi
callq 0x37e5
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: nice_exec(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>>>>, int**, int)
void nice_exec(vector<string> strargs, int** pipes, int numPipes) {
  vector<char *> cstrargs = mk_cstrvec(strargs);
  execvp(cstrargs.at(0), &cstrargs.at(0));
  // only makes it here if execvp fails
  cout << "1730sh: " << cstrargs.at(0) << ": command not found" << endl;
  // close pipes
  for(int i = 0; i < numPipes; i++) {
    close_pipe(pipes[i],false);
  } // for
  // delete dynamically-allocated members of current_jobs vector<Input*>
  for(unsigned int i = 0, s = current_jobs.size(); i < s; i++) {
    if(current_jobs[i] != nullptr) { delete current_jobs[i]; current_jobs[i] = nullptr; } // if
  } // for
  // delete dynamically-allocated pipes
  deletePipes(pipes,numPipes);
  dl_cstrvec(cstrargs);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x6e86
movq (%r15), %rsi
cmpq %rsi, 0x8(%r15)
jne 0x6be5
leaq 0x7eca(%rip), %rdi      # 0xeaa4
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3440
movq (%rsi), %rdi
callq 0x3200
movq 0xb3dc(%rip), %r15      # 0x11fd0
leaq 0x646b(%rip), %rsi      # 0xd066
movl $0x8, %edx
movq %r15, %rdi
callq 0x3300
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x6bd3
movq (%rax), %r12
testq %r12, %r12
jne 0x6c34
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x3500
jmp 0x6c4e
movq %r12, %rdi
callq 0x3130
movq 0xb38d(%rip), %rdi      # 0x11fd0
movq %r12, %rsi
movq %rax, %rdx
callq 0x3300
movq 0xb37b(%rip), %rdi      # 0x11fd0
leaq 0x6413(%rip), %rsi      # 0xd06f
movl $0x13, %edx
callq 0x3300
movq 0xb363(%rip), %rdi      # 0x11fd0
callq 0x3140
testl %ebx, %ebx
jle 0x6c9a
movl %ebx, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %r13
movl (%r13), %edi
callq 0x3580
movl 0x4(%r13), %edi
callq 0x3580
incq %r12
cmpq %r12, %r15
jne 0x6c7c
movq 0xb677(%rip), %rcx      # 0x12318
movq 0xb668(%rip), %rax      # 0x12310
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x6cf5
movl %ecx, %r12d
xorl %r13d, %r13d
movq (%rax,%r13,8), %r15
testq %r15, %r15
je 0x6ced
movq %r15, %rdi
callq 0x9b6a
movl $0xe8, %esi
movq %r15, %rdi
callq 0x32c0
movq 0xb632(%rip), %rax      # 0x12310
movq $0x0, (%rax,%r13,8)
movq 0xb623(%rip), %rax      # 0x12310
incq %r13
cmpq %r13, %r12
jne 0x6cb9
movq %r14, %rdi
movl %ebx, %esi
callq 0x6d86
leaq -0x40(%rbp), %rdi
callq 0x6fe3
movl $0x1, %edi
callq 0x3330
jmp 0x6d14
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x6d2c
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: close_pipe(int*, bool)
void close_pipe(int pipefd[2], bool exit_on_failure) {
  if(close(pipefd[0]) == -1) {
    if(exit_on_failure) { nope_out("close"); } // if
  } // if
  if(close(pipefd[1]) == -1) {
    if(exit_on_failure) { nope_out("close"); } // if
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorb $0x1, %bl
movl (%rdi), %edi
callq 0x3580
cmpl $-0x1, %eax
setne %al
orb %bl, %al
je 0x6d74
movl 0x4(%r14), %edi
callq 0x3580
cmpl $-0x1, %eax
setne %al
orb %bl, %al
je 0x6d7d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x39b0
leaq -0x30(%rbp), %rdi
callq 0x397d
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: deletePipes(int**, int)
void deletePipes(int** pipes, int numPipes) {
  if(pipes != nullptr) {
    for(int i = 0; i < numPipes; i++) {
      delete[] pipes[i];
    } // for
    delete[] pipes;
  } // if
}

// Assembly:
testq %rdi, %rdi
je 0x6dca
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x6db8
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x6db0
callq 0x3380
incq %r15
cmpq %r15, %r14
jne 0x6da2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3380
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: put_job_in_foreground(Input*, bool)
void put_job_in_foreground(Input * job, bool cont) {
  if(job != nullptr) {
    // makes JID the foreground pgrp of the terminal
    if(tcsetpgrp(shell_terminal, job->getJID()) == -1) { nope_out("tcsetpgrp"); } 
    // Send the job a continue signal, if necessary
    if(cont) {
      if(kill(-job->getJID(), SIGCONT) < 0) {
	nope_out("kill(SIGCONT)");
      } // if
    } // if
    // wait for job to finish
    wait_for_job(job); 
    // makes the shell the foreground pgrp again
    if(tcsetpgrp(shell_terminal, shell_pgid) == -1) { nope_out("tcsetpgrp"); }
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x6e28
movl %esi, %r14d
movq %rdi, %rbx
movl 0xb521(%rip), %edi      # 0x12308
movl (%rbx), %esi
callq 0x33c0
cmpl $-0x1, %eax
je 0x6e31
testb %r14b, %r14b
je 0x6e0a
xorl %edi, %edi
subl (%rbx), %edi
movl $0x12, %esi
callq 0x33d0
testl %eax, %eax
js 0x6e43
movq %rbx, %rdi
callq 0x7132
movl 0xb4f0(%rip), %edi      # 0x12308
movl 0xb4ee(%rip), %esi      # 0x1230c
callq 0x33c0
cmpl $-0x1, %eax
je 0x6e3a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3a49
leaq -0x30(%rbp), %rdi
callq 0x39e3
leaq -0x30(%rbp), %rdi
callq 0x3a16
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: put_job_in_background(Input*, bool)
void put_job_in_background(Input * job, bool cont) {
  if(job != nullptr) {
    if(cont) {
      if(kill(-job->getJID(), SIGCONT) < 0) {
	nope_out("kill(SIGCONT)");  
      } // if
    } // if
  } // if
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorb $0x1, %sil
testq %rdi, %rdi
sete %al
orb %sil, %al
jne 0x6e77
xorl %eax, %eax
subl (%rdi), %eax
movl %eax, %edi
movl $0x12, %esi
callq 0x33d0
testl %eax, %eax
js 0x6e7d
addq $0x20, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x3a7c
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: mk_cstrvec(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>>>>&)
vector<char *> mk_cstrvec(vector<string> & strvec) {
  vector<char *> cstrvec;
  for (unsigned int i = 0, s = strvec.size(); i < s; i++) {
    cstrvec.push_back(new char [strvec.at(i).size() + 1]);
    strcpy(cstrvec.at(i), strvec.at(i).c_str());
  } // for
  cstrvec.push_back(nullptr);
  return cstrvec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
subq (%rsi), %r13
shrq $0x5, %r13
testl %r13d, %r13d
je 0x6f74
movq %rsi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x6fad
movq 0x8(%rax,%r12), %rdi
incq %rdi
callq 0x3030
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6f05
movq %rax, (%rsi)
movq 0x8(%rbx), %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rbx)
jmp 0x6f15
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0xa4b8
movq 0x8(%rbx), %rdx
movq (%rbx), %rax
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x6f9c
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x6f9c
movq (%rax,%r15,8), %rdi
movq (%rcx,%r12), %rsi
callq 0x3280
incq %r15
addq $0x20, %r12
cmpl %r15d, %r13d
jne 0x6ec2
movq 0x8(%rbx), %rsi
movq $0x0, -0x30(%rbp)
cmpq 0x10(%rbx), %rsi
je 0x6f7e
movq $0x0, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x6f8a
movq $0x0, -0x30(%rbp)
xorl %esi, %esi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0xa4b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7b01(%rip), %rdi      # 0xeaa4
movq %r15, %rsi
xorl %eax, %eax
callq 0x3440
leaq 0x7af0(%rip), %rdi      # 0xeaa4
movq %r15, %rsi
xorl %eax, %eax
callq 0x3440
jmp 0x6fc4
jmp 0x6fc4
jmp 0x6fc4
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6fdb
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x32c0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/1730sh.cpp
// Function: delete_from_current_jobs(Input*)
void delete_from_current_jobs(Input * job) {
  if(job != nullptr) {
    for(unsigned int i = 0, s = current_jobs.size(); i < s; i++) {
      if(current_jobs[i] != nullptr) {
	if(job->getJID() == current_jobs[i]->getJID()) { 
	  delete job; 
	  current_jobs[i] = nullptr; 
	  break;
	} // if
      } // if
    } // for
  } // if
}

// Assembly:
testq %rdi, %rdi
je 0x7402
movq 0xaf78(%rip), %rcx      # 0x12318
movq 0xaf69(%rip), %rax      # 0x12310
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x7402
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %ecx, %ecx
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdx
testq %rdx, %rdx
je 0x73d0
movl (%rbx), %esi
cmpl (%rdx), %esi
je 0x73da
incq %r14
cmpq %r14, %rcx
jne 0x73c1
jmp 0x73fe
movq %rbx, %rdi
callq 0x9b6a
movl $0xe8, %esi
movq %rbx, %rdi
callq 0x32c0
movq 0xaf1a(%rip), %rax      # 0x12310
movq $0x0, (%rax,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: Input::Input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Input::Input(string input) {
  setShellInput(input); 
  set_foreground();
  setSTDIN();
  setSTDOUT();
  setSTDERR();
  this->processes = inputToProcesses();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
leaq 0x27bc(%rip), %rax      # 0xd101
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, -0x48(%rbp)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x78(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movb %al, 0x78(%rdi)
leaq 0x98(%rdi), %r14
movq %r14, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movb %al, 0x98(%rdi)
leaq 0xb8(%rdi), %r12
movq %r12, 0xa8(%rdi)
movq %rax, 0xb0(%rdi)
movb %al, 0xb8(%rdi)
leaq 0xd8(%rdi), %r13
movq %r13, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movb %al, 0xd8(%rdi)
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x9f52
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0xab78
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa1f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x32c0
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpb $0x26, -0x1(%rax,%rcx)
setne 0x4(%rbx)
movq %rbx, %rdi
callq 0xac34
movq %rbx, %rdi
callq 0xae7e
movq %rbx, %rdi
callq 0xb184
leaq -0x80(%rbp), %rdi
movq %rbx, %rsi
callq 0xb48e
movups 0x30(%rbx), %xmm0
movq 0x40(%rbx), %rax
leaq -0x80(%rbp), %r14
movq (%r14), %rcx
movq %rcx, 0x30(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x38(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x40(%rbx)
leaq -0x98(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x9e6a
movq %r14, %rdi
callq 0x9e6a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaacd
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xaad1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x32c0
jmp 0xaad1
movq %rax, -0x30(%rbp)
movq 0xc8(%rbx), %rdi
cmpq %r13, %rdi
je 0xaae9
movq (%r13), %rsi
incq %rsi
callq 0x32c0
movq 0xa8(%rbx), %rdi
cmpq %r12, %rdi
je 0xab01
movq (%r12), %rsi
incq %rsi
callq 0x32c0
movq 0x88(%rbx), %rdi
cmpq %r14, %rdi
je 0xab18
movq (%r14), %rsi
incq %rsi
callq 0x32c0
movq 0x68(%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xab31
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32c0
leaq 0x30(%rbx), %r15
movq 0x48(%rbx), %rdi
cmpq -0x40(%rbp), %rdi
je 0xab4e
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32c0
movq %r15, %rdi
callq 0x9e6a
movq 0x10(%rbx), %rdi
cmpq -0x48(%rbp), %rdi
je 0xab6f
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32c0
movq -0x30(%rbp), %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: Input::setShellInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Input::setShellInput(string input) {
  const char * ws = " \t"; // chars to trim
  input = input.erase(input.find_last_not_of(ws) + 1); // trims end 
  input = input.erase(0, input.find_first_not_of(ws)); // trims beginning  
  this->shellInput = input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3f84(%rip), %rsi      # 0xeb10
movl $0x2, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x3480
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0xac03
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3180
leaq 0x3f47(%rip), %rsi      # 0xeb10
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x34f0
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x3080
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3180
addq $0x10, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3180
leaq 0x3f58(%rip), %rdi      # 0xeb62
leaq 0x3f3d(%rip), %rsi      # 0xeb4e
movq %rax, %rdx
xorl %eax, %eax
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: Input::setJID(int)
void Input::setJID(pid_t pgid) {
  this->JID = pgid;
  for(int i = 0, s = processes.size(); i < s; i++) {
    processes[i].PGID = pgid;
  } // for
}

// Assembly:
movl %esi, (%rdi)
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
testl %ecx, %ecx
jle 0xc0f5
pushq %rbp
movq %rsp, %rbp
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq $0x4, %rax
movl %esi, (%rax)
addq $0x28, %rax
decq %rcx
jne 0xc0e9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: Input::getNumPipes() const
const int Input::getNumPipes() const {
  int pipes = 0;
  for(unsigned int i = 0; i < processes.size(); i++) {
    if(processes[i].hasPipe) { // if not the last process in input
      pipes++;
    } // if
  } // for
  return pipes;
}

// Assembly:
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rax
subq %rcx, %rax
je 0xc138
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
addq $0xa, %rcx
xorl %eax, %eax
movl $0x1, %esi
movzbl (%rcx), %edi
addl %edi, %eax
movl %esi, %edi
addq $0x28, %rcx
incl %esi
cmpq %rdi, %rdx
ja 0xc124
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: Input::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Input& Input::operator=(string input) {
  setShellInput(input); 
  set_foreground();
  setSTDIN();
  setSTDOUT();
  setSTDERR();
  this->processes = inputToProcesses();
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x9f52
movq %rbx, %rdi
movq %r14, %rsi
callq 0xab78
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xc265
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32c0
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
cmpb $0x26, -0x1(%rax,%rcx)
setne 0x4(%rbx)
movq %rbx, %rdi
callq 0xac34
movq %rbx, %rdi
callq 0xae7e
movq %rbx, %rdi
callq 0xb184
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb48e
movups 0x30(%rbx), %xmm0
movq 0x40(%rbx), %rax
movq (%r14), %rcx
movq %rcx, 0x30(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x38(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x40(%rbx)
leaq -0x68(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x9e6a
movq %r14, %rdi
callq 0x9e6a
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xc309
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3530