LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ralgond[P]SortedListIntersection/algo_bisearch.cpp
// Function: bisearch_intersection(unsigned int const*, unsigned int, unsigned int const*, unsigned int, unsigned int*)
uint32_t bisearch_intersection(const uint32_t* a, uint32_t a_len, const uint32_t* b, uint32_t b_len, uint32_t* c) {
	uint32_t c_pos = 0;
	for (int i = 0; i < b_len; i++) {
		if (bisearch(a, a_len, b[i]) >= 0) {
			c[c_pos++] = b[i];
		}
	}

	return c_pos;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x4fc8
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
callq 0xde00
cmpl $0x0, %eax
jl 0x4fb9
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rsp)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x4fbb
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4f6b
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ralgond[P]SortedListIntersection/algo_bloomfilter.cpp
// Function: bloomfilter_intersection(bloom_filter*, unsigned int const*, unsigned int, unsigned int const*, unsigned int, unsigned int*)
uint32_t bloomfilter_intersection(bloom_filter* filter, const uint32_t* a, uint32_t a_len, const uint32_t* b, uint32_t b_len, uint32_t* c) {
	uint32_t c_pos = 0;
	for (int i = 0; i < b_len; i++) {
		int b_data = b[i];
		if (filter->contains(b_data)) {
			if (bisearch(a, a_len, b_data) >= 0) {
				c[c_pos++] = b_data;
			}
		}
	}
	return c_pos;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x5304
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5440
testb $0x1, %al
jne 0x52c1
jmp 0x52f5
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0xde00
cmpl $0x0, %eax
jl 0x52f3
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x14(%rsp)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x52f5
jmp 0x52f7
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5291
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: ralgond[P]SortedListIntersection/algo_bloomfilter.cpp
// Function: create_bloom_filter(unsigned int const*, unsigned int)
bloom_filter* create_bloom_filter(const uint32_t* a, uint32_t a_len) {
	bloom_parameters parameters;
	
	parameters.projected_element_count = a_len;
	
	parameters.false_positive_probability = 0.0001;
	
	parameters.random_seed = 0xA5A5A5A5;

	parameters.compute_optimal_parameters();

	bloom_filter* filter = new bloom_filter(parameters);


	for (int i = 0; i < a_len; i++) {
		filter->insert(a[i]);
	}

	return filter;

}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5470
movq 0x18(%rsp), %rdi
movl 0x8c(%rsp), %eax
movq %rax, 0x60(%rsp)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0x68(%rsp)
movl $0xa5a5a5a5, %eax       # imm = 0xA5A5A5A5
movq %rax, 0x70(%rsp)
callq 0x5500
jmp 0x5366
movl $0x68, %edi
callq 0x21e0
movq %rax, 0x10(%rsp)
jmp 0x5377
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5740
jmp 0x5388
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jae 0x5402
movq 0x28(%rsp), %rdi
movq 0x90(%rsp), %rax
movslq 0x24(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
callq 0x5840
jmp 0x53c4
jmp 0x53c6
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x539a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x5423
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x68, %esi
callq 0x21f0
jmp 0x5423
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5870
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0x5870
movq 0x38(%rsp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::bloom_filter(bloom_parameters const&)
bloom_filter(const bloom_parameters& p)
   : projected_element_count_(p.projected_element_count),
     inserted_element_count_(0),
     random_seed_((p.random_seed * 0xA5A5A5A5) + 1),
     desired_false_positive_probability_(p.false_positive_probability)
   {
      salt_count_ = p.optimal_parameters.number_of_hashes;
      table_size_ = p.optimal_parameters.table_size;

      generate_unique_salt();

      bit_table_.resize(table_size_ / bits_per_char, static_cast<unsigned char>(0x00));
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0xc619(%rip), %rax      # 0x11d78
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0x5a20
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0x5a30
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movl $0xa5a5a5a5, %ecx       # imm = 0xA5A5A5A5
imulq %rcx, %rax
incq %rax
movq %rax, 0x58(%rdi)
movq 0x28(%rsp), %rax
vmovsd 0x28(%rax), %xmm0
vmovsd %xmm0, 0x60(%rdi)
movq 0x28(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x38(%rdi)
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x40(%rdi)
callq 0x5a40
jmp 0x57e3
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x40(%rax), %rsi
shrq $0x3, %rsi
movb $0x0, 0x1b(%rsp)
leaq 0x1b(%rsp), %rdx
callq 0x5cb0
jmp 0x5808
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x5d70
movq (%rsp), %rdi
callq 0x5dd0
movq 0x20(%rsp), %rdi
callq 0x2330
nopl (%rax,%rax)
// File: ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_parameters::operator!()
inline bool operator!()
   {
      return (minimum_size > maximum_size)      ||
             (minimum_number_of_hashes > maximum_number_of_hashes) ||
             (minimum_number_of_hashes < 1)     ||
             (0 == maximum_number_of_hashes)    ||
             (0 == projected_element_count)     ||
             (false_positive_probability < 0.0) ||
             (std::numeric_limits<double>::infinity() == std::abs(false_positive_probability)) ||
             (0 == random_seed)                 ||
             (0xFFFFFFFFFFFFFFFFULL == random_seed);
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rdx), %rcx
movb $0x1, %al
cmpq 0x10(%rdx), %rcx
movb %al, 0x1f(%rsp)
ja 0x59e0
movq 0x10(%rsp), %rdx
movl 0x18(%rdx), %ecx
movb $0x1, %al
cmpl 0x1c(%rdx), %ecx
movb %al, 0x1f(%rsp)
ja 0x59e0
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpl $0x1, 0x18(%rcx)
movb %al, 0x1f(%rsp)
jb 0x59e0
movq 0x10(%rsp), %rdx
movb $0x1, %al
xorl %ecx, %ecx
cmpl 0x1c(%rdx), %ecx
movb %al, 0x1f(%rsp)
je 0x59e0
movq 0x10(%rsp), %rdx
movb $0x1, %al
xorl %ecx, %ecx
cmpq 0x20(%rdx), %rcx
movb %al, 0x1f(%rsp)
je 0x59e0
movq 0x10(%rsp), %rcx
movb $0x1, %al
vpxor %xmm0, %xmm0, %xmm0
vucomisd 0x28(%rcx), %xmm0
movb %al, 0x1f(%rsp)
ja 0x59e0
callq 0x59f0
movq 0x10(%rsp), %rax
vmovsd %xmm0, 0x8(%rsp)
vmovsd 0x28(%rax), %xmm0
callq 0x5a00
vmovaps %xmm0, %xmm1
vmovsd 0x8(%rsp), %xmm0
movb $0x1, %al
vucomisd %xmm1, %xmm0
movb %al, 0x1f(%rsp)
jne 0x59b6
jp 0x59b6
jmp 0x59e0
movq 0x10(%rsp), %rdx
movb $0x1, %al
xorl %ecx, %ecx
cmpq 0x30(%rdx), %rcx
movb %al, 0x1f(%rsp)
je 0x59e0
movq 0x10(%rsp), %rcx
movq $-0x1, %rax
cmpq 0x30(%rcx), %rax
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::contains(unsigned char const*, unsigned long) const
inline virtual bool contains(const unsigned char* key_begin, const std::size_t length) const
   {
      std::size_t bit_index = 0;
      std::size_t bit       = 0;

      for (std::size_t i = 0; i < salt_.size(); ++i)
      {
         compute_indices(hash_ap(key_begin, length, salt_[i]), bit_index, bit);

         if ((bit_table_[bit_index / bits_per_char] & bit_mask[bit]) != bit_mask[bit])
         {
            return false;
         }
      }

      return true;
   }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rdi
callq 0x61e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x5fb8
movq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0x8930
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rdi
movl (%rax), %ecx
callq 0x8710
movq 0x20(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movq (%rdi), %rax
leaq 0x2c(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
callq *0x20(%rax)
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x40(%rsp), %rsi
shrq $0x3, %rsi
callq 0x8950
movzbl (%rax), %eax
movq 0x38(%rsp), %rdx
leaq 0x842f(%rip), %rcx      # 0xe3b1
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movq 0x38(%rsp), %rdx
leaq 0x841d(%rip), %rcx      # 0xe3b1
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x5fa3
movb $0x0, 0x67(%rsp)
jmp 0x5fbd
jmp 0x5fa5
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x5ed8
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: ralgond[P]SortedListIntersection/./bloom_filter.hpp
// Function: bloom_filter::insert(unsigned char const*, unsigned long const&)
inline void insert(const unsigned char* key_begin, const std::size_t& length)
   {
      std::size_t bit_index = 0;
      std::size_t bit       = 0;

      for (std::size_t i = 0; i < salt_.size(); ++i)
      {
         compute_indices(hash_ap(key_begin, length, salt_[i]), bit_index, bit);

         bit_table_[bit_index / bits_per_char] |= bit_mask[bit];
      }

      ++inserted_element_count_;
   }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x8, %rdi
callq 0x61e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x8a78
movq 0x28(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movq 0x38(%rsp), %rsi
callq 0x6200
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rdi
movl (%rax), %ecx
callq 0x8710
movq 0x28(%rsp), %rdi
movl %eax, 0x34(%rsp)
movq (%rdi), %rax
leaq 0x34(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq *0x20(%rax)
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x5971(%rip), %rax      # 0xe3b1
movzbl (%rax,%rcx), %eax
movl %eax, 0x1c(%rsp)
addq $0x20, %rdi
movq 0x48(%rsp), %rsi
shrq $0x3, %rsi
callq 0x8a90
movl 0x1c(%rsp), %edx
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x89a8
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
addq $0x68, %rsp
retq
nop
// File: ralgond[P]SortedListIntersection/algo_highlyscalable_avx2.cpp
// Function: prepare_shuffling_dict32()
void prepare_shuffling_dict32() {
        for (int i = 0; i  < 256; i++) {
                int counter = 0;
                char permutation[32];
                memset(permutation, 0xFF, sizeof(permutation));
                for (char b = 0; b < 8; b++) {
                        if (getBit(i, b)) {
                                //permutation[counter++] = 4*b;
                                //permutation[counter++] = 4*b + 1;
                                //permutation[counter++] = 4*b + 2;
                                //permutation[counter++] = 4*b + 3;
				
				permutation[counter++] = b & 0xff;
                                permutation[counter++] = (b >> 8) & 0xff;
                                permutation[counter++] = (b >> 16) & 0xff;
                                permutation[counter++] = (b >> 24) & 0xff;

                        }
                }
                __m256i mask = _mm256_loadu_si256((const __m256i*)permutation);
                shuffle_mask32[i] = mask;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x80, %rsp
movl $0x0, 0x64(%rsp)
cmpl $0x100, 0x64(%rsp)      # imm = 0x100
jge 0x9878
movl $0x0, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
movl $0xff, %esi
movl $0x20, %edx
vzeroupper
callq 0x2100
movb $0x0, 0x3f(%rsp)
movsbl 0x3f(%rsp), %eax
cmpl $0x8, %eax
jge 0x9834
movl 0x64(%rsp), %edi
movsbl 0x3f(%rsp), %esi
callq 0x9880
cmpl $0x0, %eax
je 0x9823
movsbl 0x3f(%rsp), %eax
andl $0xff, %eax
movb %al, %cl
movl 0x60(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rsp)
cltq
movb %cl, 0x40(%rsp,%rax)
movsbl 0x3f(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movl 0x60(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rsp)
cltq
movb %cl, 0x40(%rsp,%rax)
movsbl 0x3f(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movl 0x60(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rsp)
cltq
movb %cl, 0x40(%rsp,%rax)
movsbl 0x3f(%rsp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movl 0x60(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rsp)
cltq
movb %cl, 0x40(%rsp,%rax)
jmp 0x9825
movb 0x3f(%rsp), %al
addb $0x1, %al
movb %al, 0x3f(%rsp)
jmp 0x9779
leaq 0x40(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
vmovdqu (%rax), %ymm0
vmovdqa %ymm0, (%rsp)
vmovdqa (%rsp), %ymm0
movslq 0x64(%rsp), %rcx
leaq 0x8ae3(%rip), %rax      # 0x12340
shlq $0x5, %rcx
addq %rcx, %rax
vmovdqa %ymm0, (%rax)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x9747
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: ralgond[P]SortedListIntersection/algo_highlyscalable_avx2.cpp
// Function: main1()
int main1() {
        prepare_shuffling_dict32();

        uint32_t A[8] = {1, 3, 7, 19, 23, 31, 37, 41};
        uint32_t B[8] = {2, 4, 7, 19, 24, 31, 39, 40};
        uint32_t* C = new uint32_t[8];
        
	uint32_t count = highlyscalable_avx2_intersection(A, 8, B, 8, C);
	cout<<"count="<<count<<endl;
        for (int i = 0; i < count; i++) {
                cout<<C[i]<<endl;
        }
        return 0;
}

// Assembly:
subq $0x58, %rsp
callq 0x9730
movq 0x4650(%rip), %rax      # 0xe580
movq %rax, 0x30(%rsp)
movq 0x464c(%rip), %rax      # 0xe588
movq %rax, 0x38(%rsp)
movq 0x4648(%rip), %rax      # 0xe590
movq %rax, 0x40(%rsp)
movq 0x4644(%rip), %rax      # 0xe598
movq %rax, 0x48(%rsp)
movq 0x4640(%rip), %rax      # 0xe5a0
movq %rax, 0x10(%rsp)
movq 0x463c(%rip), %rax      # 0xe5a8
movq %rax, 0x18(%rsp)
movq 0x4638(%rip), %rax      # 0xe5b0
movq %rax, 0x20(%rsp)
movq 0x4634(%rip), %rax      # 0xe5b8
movq %rax, 0x28(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
movl $0x8, %ecx
movq %rcx, %rsi
callq 0x98b0
movl %eax, 0x4(%rsp)
movq 0x8019(%rip), %rdi      # 0x11fd8
leaq 0x408c(%rip), %rsi      # 0xe052
callq 0x21d0
movq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x2270
movq %rax, %rdi
movq 0x7fe7(%rip), %rsi      # 0x11fc8
callq 0x2200
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0xa028
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x7fcf(%rip), %rdi      # 0x11fd8
callq 0x2270
movq %rax, %rdi
movq 0x7fb0(%rip), %rsi      # 0x11fc8
callq 0x2200
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x9fed
xorl %eax, %eax
addq $0x58, %rsp
retq
nop
// File: ralgond[P]SortedListIntersection/algo_highlyscalable_avx512.cpp
// Function: prepare_shuffling_dict64()
void prepare_shuffling_dict64() {
        for (int i = 0; i  < 65536; i++) {
                int counter = 0;
                char permutation[64];
                memset(permutation, 0xFF, sizeof(permutation));
                for (char b = 0; b < 16; b++) {
                        if (getBit(i, b)) {
				permutation[counter++] = b & 0xff;
                                permutation[counter++] = (b >> 8) & 0xff;
                                permutation[counter++] = (b >> 16) & 0xff;
                                permutation[counter++] = (b >> 24) & 0xff;

                        }
                }
                __m512i mask = _mm512_loadu_si512(permutation);
                shuffle_mask64[i] = mask;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0xc0, %rsp
movl $0x0, 0xa4(%rsp)
cmpl $0x10000, 0xa4(%rsp) # imm = 0x10000
jge 0xa1b3
movl $0x0, 0xa0(%rsp)
leaq 0x60(%rsp), %rdi
movl $0xff, %esi
movl $0x40, %edx
vzeroupper
callq 0x2100
movb $0x0, 0x5f(%rsp)
movsbl 0x5f(%rsp), %eax
cmpl $0x10, %eax
jge 0xa158
movl 0xa4(%rsp), %edi
movsbl 0x5f(%rsp), %esi
callq 0xa1c0
cmpl $0x0, %eax
je 0xa147
movsbl 0x5f(%rsp), %eax
andl $0xff, %eax
movb %al, %cl
movl 0xa0(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa0(%rsp)
cltq
movb %cl, 0x60(%rsp,%rax)
movsbl 0x5f(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movl 0xa0(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa0(%rsp)
cltq
movb %cl, 0x60(%rsp,%rax)
movsbl 0x5f(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movl 0xa0(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa0(%rsp)
cltq
movb %cl, 0x60(%rsp,%rax)
movsbl 0x5f(%rsp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movl 0xa0(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa0(%rsp)
cltq
movb %cl, 0x60(%rsp,%rax)
jmp 0xa149
movb 0x5f(%rsp), %al
addb $0x1, %al
movb %al, 0x5f(%rsp)
jmp 0xa082
leaq 0x60(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
vmovdqu64 (%rax), %zmm0
vmovdqa64 %zmm0, (%rsp)
vmovdqa64 (%rsp), %zmm0
movslq 0xa4(%rsp), %rcx
leaq 0xa1f0(%rip), %rax      # 0x14380
shlq $0x6, %rcx
addq %rcx, %rax
vmovdqa64 %zmm0, (%rax)
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0xa04a
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax,%rax)
// File: ralgond[P]SortedListIntersection/algo_scalar.cpp
// Function: scalar(unsigned int const*, unsigned long, unsigned int const*, unsigned long, unsigned int*)
size_t scalar(const uint32_t *A, const size_t lenA, const uint32_t *B,
              const size_t lenB, uint32_t *out) {
  const uint32_t *const initout(out);
  if (lenA == 0 || lenB == 0)
    return 0;

  const uint32_t *endA = A + lenA;
  const uint32_t *endB = B + lenB;

  while (1) {
    while (*A < *B) {
    SKIP_FIRST_COMPARE:
      if (++A == endA)
        return (out - initout);
    }
    while (*A > *B) {
      if (++B == endB)
        return (out - initout);
    }
    if (*A == *B) {
      *out++ = *A;
      if (++A == endA || ++B == endB)
        return (out - initout);
    } else {
      goto SKIP_FIRST_COMPARE;
    }
  }

  return (out - initout); // NOTREACHED
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa913
cmpq $0x0, -0x28(%rsp)
jne 0xa921
movq $0x0, -0x8(%rsp)
jmp 0xaa4c
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rsp)
jmp 0xa94f
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jae 0xa993
jmp 0xa961
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
cmpq -0x40(%rsp), %rax
jne 0xa991
movq -0x30(%rsp), %rax
movq -0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x8(%rsp)
jmp 0xaa4c
jmp 0xa94f
jmp 0xa995
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0xa9d4
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rsp)
cmpq -0x48(%rsp), %rax
jne 0xa9d2
movq -0x30(%rsp), %rax
movq -0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x8(%rsp)
jmp 0xaa4c
jmp 0xa995
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xaa42
movq -0x10(%rsp), %rax
movl (%rax), %ecx
movq -0x30(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x30(%rsp)
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
cmpq -0x40(%rsp), %rax
je 0xaa28
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rsp)
cmpq -0x48(%rsp), %rax
jne 0xaa40
movq -0x30(%rsp), %rax
movq -0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x8(%rsp)
jmp 0xaa4c
jmp 0xaa47
jmp 0xa961
jmp 0xa94d
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: ralgond[P]SortedListIntersection/algo_scalar.cpp
// Function: match_scalar(unsigned int const*, unsigned long, unsigned int const*, unsigned long, unsigned int*)
size_t match_scalar(const uint32_t *A, const size_t lenA, const uint32_t *B, const size_t lenB, uint32_t *out) {

  const uint32_t *initout = out;
  if (lenA == 0 || lenB == 0)
    return 0;

  const uint32_t *endA = A + lenA;
  const uint32_t *endB = B + lenB;

  while (1) {
    while (*A < *B) {
    SKIP_FIRST_COMPARE:
      if (++A == endA)
        goto FINISH;
    }
    while (*A > *B) {
      if (++B == endB)
        goto FINISH;
    }
    if (*A == *B) {
      *out++ = *A;
      if (++A == endA || ++B == endB)
        goto FINISH;
    } else {
      goto SKIP_FIRST_COMPARE;
    }
  }

FINISH:
  return (out - initout);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xaa93
cmpq $0x0, -0x28(%rsp)
jne 0xaaa1
movq $0x0, -0x8(%rsp)
jmp 0xaba0
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rsp)
jmp 0xaacf
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jae 0xaafd
jmp 0xaae1
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
cmpq -0x40(%rsp), %rax
jne 0xaafb
jmp 0xab8a
jmp 0xaacf
jmp 0xaaff
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0xab28
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rsp)
cmpq -0x48(%rsp), %rax
jne 0xab26
jmp 0xab8a
jmp 0xaaff
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xab80
movq -0x10(%rsp), %rax
movl (%rax), %ecx
movq -0x30(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x30(%rsp)
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
cmpq -0x40(%rsp), %rax
je 0xab7c
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rsp)
cmpq -0x48(%rsp), %rax
jne 0xab7e
jmp 0xab8a
jmp 0xab85
jmp 0xaae1
jmp 0xaacd
movq -0x30(%rsp), %rax
movq -0x38(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: ralgond[P]SortedListIntersection/sorted_int_file_reader.cpp
// Function: read_sorted_int_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int*)
uint32_t* read_sorted_int_from_file(string filepath, uint32_t* size) {
	ifstream inf(filepath);
	if (inf) {
		vector<uint32_t> v;
		string line;
		while (getline(inf, line)) {
			int num = atoi(line.c_str());
			v.push_back(num);
		}

		*size = v.size();
		uint32_t* ret = new uint32_t[*size];
		for (int i = 0; i < v.size(); i++) {
			ret[i] = v.at(i);
		}
		return ret;
	} else {
		return NULL;
	}
}

// Assembly:
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, 0x2a8(%rsp)
movq %rax, 0x2a0(%rsp)
leaq 0x98(%rsp), %rdi
movl $0x8, %edx
callq 0x22d0
movq 0x98(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x98(%rsp,%rax), %rdi
callq 0x2260
movb %al, 0x37(%rsp)
jmp 0xd7ce
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0xd7db
jmp 0xd96a
leaq 0x70(%rsp), %rdi
callq 0x5a20
leaq 0x50(%rsp), %rdi
callq 0x2280
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2050
movq %rax, 0x28(%rsp)
jmp 0xd808
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2260
movb %al, 0x27(%rsp)
jmp 0xd822
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xd82c
jmp 0xd8a3
leaq 0x50(%rsp), %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x22c0
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x48(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd9c0
jmp 0xd85b
jmp 0xd7ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xd99b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2110
leaq 0x70(%rsp), %rdi
callq 0x5dd0
jmp 0xd99b
leaq 0x70(%rsp), %rdi
callq 0x61e0
movl %eax, %ecx
movq 0x2a0(%rsp), %rax
movl %ecx, (%rax)
movq 0x2a0(%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2030
movq %rax, 0x18(%rsp)
jmp 0xd8d5
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x61e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xd93f
movslq 0x3c(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xd9f0
movq %rax, 0x8(%rsp)
jmp 0xd91e
movq 0x8(%rsp), %rax
movl (%rax), %edx
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0xd8e7
movq 0x40(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2110
leaq 0x70(%rsp), %rdi
callq 0x5dd0
jmp 0xd97e
movq $0x0, 0x2b0(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x2060
movq 0x2b0(%rsp), %rax
addq $0x2b8, %rsp            # imm = 0x2B8
retq
leaq 0x98(%rsp), %rdi
callq 0x2060
movq 0x90(%rsp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
nop
// File: ralgond[P]SortedListIntersection/utils.cpp
// Function: bisearch(unsigned int const*, unsigned int, unsigned int)
int bisearch(const uint32_t* a, uint32_t a_len, uint32_t target) {
	int low = 0;
	int high = a_len - 1;

	while (high-low > 4) {
		int mid = low + (high-low) / 2;
		int mid_v = a[mid];
		if (mid_v == target)
			return mid;
		else if (target < mid_v)
			high = mid - 1;
		else
			low = mid + 1;
	}

	int i = low;
	for (; i<=high; i++) {
		if (!(a[i] < target))
			break;
	}

	if (a[i] == target)
		return i;
	else
		return -1*(i+1);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
subl -0x1c(%rsp), %eax
cmpl $0x4, %eax
jle 0xde9f
movl -0x1c(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x20(%rsp), %eax
subl -0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rsp), %eax
addl %ecx, %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x18(%rsp), %eax
jne 0xde79
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xdf03
movl -0x18(%rsp), %eax
cmpl -0x28(%rsp), %eax
jae 0xde90
movl -0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0xde9b
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xde9d
jmp 0xde20
movl -0x1c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x20(%rsp), %eax
jg 0xded5
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rsp), %eax
jb 0xdec6
jmp 0xded5
jmp 0xdec8
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0xdea7
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rsp), %eax
jne 0xdef2
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xdf03
movl -0x2c(%rsp), %eax
addl $0x1, %eax
imull $0xffffffff, %eax, %eax # imm = 0xFFFFFFFF
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: kdungs[P]codecon/src/rugby.cc
// Function: main
int main() {
  int score;
  std::cin >> score;

  for (auto co = 0; co <= score / 7; ++co) {
    const auto afterCo = score - 7 * co;
    for (auto tr = 0; tr <= afterCo / 3; ++tr) {
      const auto afterTr = afterCo - 3 * tr;
      if (afterTr % 2 == 0) {
        auto ki = afterTr / 2;
        std::cout << co << ' ' << tr << ' ' << ki << '\n';
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e0a(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
callq 0x1030
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jg 0x12cb
movl -0x8(%rbp), %eax
imull $0x7, -0xc(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jg 0x12bb
movl -0x10(%rbp), %eax
imull $0x3, -0x14(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x12ab
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %esi
movq 0x2d67(%rip), %rdi      # 0x3fd0
callq 0x1070
movq %rax, %rdi
movl $0x20, %esi
callq 0x1050
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movl $0x20, %esi
callq 0x1050
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movl $0xa, %esi
callq 0x1050
jmp 0x12ad
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1217
jmp 0x12bd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11e6
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: louisabraham[P]cage/./cage.hpp
// Function: luby(int)
long long luby(int x)
{
    // Find the finite subsequence that contains index 'x', and the
    // size of that subsequence:
    int size, seq;
    for (size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1)
        ;

    while (size - 1 != x)
    {
        size = (size - 1) >> 1;
        seq--;
        x = x % size;
    }

    return 1LL << seq;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x1, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0x8(%rsp), %eax
movl -0x4(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x132f
jmp 0x1315
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x1304
jmp 0x1331
movl -0x8(%rsp), %eax
subl $0x1, %eax
cmpl -0x4(%rsp), %eax
je 0x1365
movl -0x8(%rsp), %eax
subl $0x1, %eax
sarl %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x4(%rsp), %eax
cltd
idivl -0x8(%rsp)
movl %edx, -0x4(%rsp)
jmp 0x1331
movl -0xc(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
retq
nopw %cs:(%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/token.cpp
// Function: operator<<(std::ostream&, Token&)
ostream& operator<< (ostream &os, Token& a)
{
   os << "Token: " << spellS(a.getSymbol()) << endl
      << "\tAttributes: " << endl
      << "\t\tLexeme: " << a.getLexeme() << endl
      << "\t\tValue: " << a.getValue() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1879d(%rip), %rsi     # 0x1f37b
callq 0x21b0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d70
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5c50
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x2190
movq %rax, -0x68(%rbp)
jmp 0x6c12
movq -0x68(%rbp), %rdi
movq 0x2039b(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, -0x80(%rbp)
jmp 0x6c28
movq -0x80(%rbp), %rdi
leaq 0x18750(%rip), %rsi     # 0x1f383
callq 0x21b0
movq %rax, -0x88(%rbp)
jmp 0x6c41
movq -0x88(%rbp), %rdi
movq 0x20369(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, -0x90(%rbp)
jmp 0x6c5d
movq -0x90(%rbp), %rdi
leaq 0x18726(%rip), %rsi     # 0x1f391
callq 0x21b0
movq %rax, -0x98(%rbp)
jmp 0x6c79
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6d90
jmp 0x6c88
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2190
movq %rax, -0xa0(%rbp)
jmp 0x6ca1
movq -0xa0(%rbp), %rdi
movq 0x20309(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, -0xa8(%rbp)
jmp 0x6cbd
movq -0xa8(%rbp), %rdi
leaq 0x186d1(%rip), %rsi     # 0x1f39c
callq 0x21b0
movq %rax, -0xb0(%rbp)
jmp 0x6cd9
movq -0x10(%rbp), %rdi
callq 0x6dc0
movl %eax, -0xb4(%rbp)
jmp 0x6cea
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdi
callq 0x2320
movq %rax, -0xc0(%rbp)
jmp 0x6d05
movq -0xc0(%rbp), %rdi
movq 0x202a5(%rip), %rsi     # 0x26fb8
callq 0x21d0
jmp 0x6d1a
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
ud2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6d51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x38(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Symtable::search(string s)
{
   Token a;
   string comp;
   for (/*std::size_t*/int i = 0; i < 307; i++)//check all the loctions that are
      //occupied
   {
      a = htable[i];
      comp = a.getLexeme();
      if ( spellS (a.getSymbol()) != "NONAME")
      {
	 if ( comp == s )
	 {
	    return i;//if found return it's location
	 }
	 else
	    ;
      }
      else
	 ;
   }
   return -1;//return -1 if not found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11270
leaq -0x68(%rbp), %rdi
callq 0x22a0
movl $0x0, -0x6c(%rbp)
cmpl $0x133, -0x6c(%rbp)     # imm = 0x133
jge 0x1084c
movq -0xd0(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
callq 0x10ed0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x11320
jmp 0x10759
leaq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6d90
jmp 0x1076b
leaq -0x68(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
callq 0x2240
movq -0xe8(%rbp), %rdi
callq 0x2130
leaq -0x48(%rbp), %rdi
callq 0x6d70
movl %eax, -0xdc(%rbp)
jmp 0x1079f
movl -0xdc(%rbp), %esi
leaq -0xc0(%rbp), %rdi
callq 0x5c50
jmp 0x107b3
leaq 0xeb4b(%rip), %rsi      # 0x1f305
leaq -0xc0(%rbp), %rdi
callq 0x11240
movb %al, -0xe9(%rbp)
jmp 0x107ce
leaq -0xc0(%rbp), %rdi
callq 0x2130
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x107e6
jmp 0x1083a
movq -0xd8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x11360
testb $0x1, %al
jne 0x107fc
jmp 0x10836
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xc4(%rbp)
jmp 0x1085d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1087b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2130
jmp 0x1087b
jmp 0x10838
jmp 0x1083c
jmp 0x1083c
jmp 0x1083e
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x1072e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0xc4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x48(%rbp), %rdi
callq 0x5b20
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x48(%rbp), %rdi
callq 0x5b20
movq -0x78(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::printTable()
void Symtable::printTable()
{
   Token a;
   for (std::size_t i = 0; i < 307; i++)
   {
      a = htable[i];
      if (spellS (a.getSymbol()) != "NONAME")
      {
	 cout << a;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11270
movq $0x0, -0x40(%rbp)
cmpq $0x133, -0x40(%rbp)     # imm = 0x133
jae 0x109c0
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x10ed0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x11320
jmp 0x10931
leaq -0x38(%rbp), %rdi
callq 0x6d70
movl %eax, -0x7c(%rbp)
jmp 0x1093f
movl -0x7c(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x5c50
jmp 0x1094d
leaq 0xe9b1(%rip), %rsi      # 0x1f305
leaq -0x70(%rbp), %rdi
callq 0x11240
movb %al, -0x7d(%rbp)
jmp 0x10962
leaq -0x70(%rbp), %rdi
callq 0x2130
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0x10974
jmp 0x109ad
movq 0x1664d(%rip), %rdi     # 0x26fc8
leaq -0x38(%rbp), %rsi
callq 0x6bc0
jmp 0x10986
jmp 0x109ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x109d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x109d2
jmp 0x109af
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x10908
leaq -0x38(%rbp), %rdi
callq 0x5b20
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5b20
movq -0x48(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::scan()
int Admin::scan()
{
   char now[256];
   input.open(in.c_str());
   do{
      //clearing the array of characters
      for(int j=0;j<255;j++)
	 now[j]=' ';  
      input.getline(now,256);   
      view.tokenLine(now, 256);
      view.LN++;
      lineNo++;
   }while(!input.eof());
/*
  for debuging purposes
  view.symbolTable.printTable();
  
*/
input.close();
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x120(%rbp)
addq $0x610, %rdi            # imm = 0x610
callq 0x20c0
movq -0x120(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x2140
movl $0x0, -0x114(%rbp)
cmpl $0xff, -0x114(%rbp)
jge 0x1289e
movslq -0x114(%rbp), %rax
movb $0x20, -0x110(%rbp,%rax)
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x12872
movq -0x128(%rbp), %rdi
addq $0x8, %rdi
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x2090
movq -0x128(%rbp), %rdi
addq $0x670, %rdi            # imm = 0x670
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x13c50
movq -0x128(%rbp), %rax
movl 0x1298(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1298(%rax)
movl 0x1ce0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1ce0(%rax)
movq -0x128(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x2380
xorb $-0x1, %al
testb $0x1, %al
jne 0x12868
movq -0x128(%rbp), %rdi
addq $0x8, %rdi
callq 0x2050
movl $0x1, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Admin::emit1(string OP)
{
   outsource.open(codeGen, ios::app);
   
   if (emitting)
   {
      outsource << OP << endl;
   }
   outsource.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, %rdi
addq $0x410, %rdi            # imm = 0x410
addq $0x650, %rsi            # imm = 0x650
movl $0x1, %edx
callq 0x2100
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x12f53
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
callq 0x2190
movq %rax, %rdi
movq 0x1406a(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x18(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
callq 0x22b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Admin::emit2 (string OP, int arg1)
{
   outsource.open(codeGen, ios::app);
   if (emitting)
   {
      outsource << OP << endl << arg1 << endl;
   }
   outsource.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq %rsi, %rdi
addq $0x410, %rdi            # imm = 0x410
addq $0x650, %rsi            # imm = 0x650
movl $0x1, %edx
callq 0x2100
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x12ff0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
callq 0x2190
movq %rax, %rdi
movq 0x13fe7(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2320
movq %rax, %rdi
movq 0x13fcd(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x20(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
callq 0x22b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void Admin::emit3 (string OP, int arg1, int arg2)
{
   outsource.open(codeGen, ios::app);
   if (emitting)
   {
      outsource << OP << endl << arg1 << endl << arg2 << endl;
   }
   outsource.close();
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq %rsi, %rdi
addq $0x410, %rdi            # imm = 0x410
addq $0x650, %rsi            # imm = 0x650
movl $0x1, %edx
callq 0x2100
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x130ad
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
callq 0x2190
movq %rax, %rdi
movq 0x13f44(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2320
movq %rax, %rdi
movq 0x13f2a(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2320
movq %rax, %rdi
movq 0x13f10(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x20(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
callq 0x22b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::Scanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Scanner::Scanner(string inCodeName, string outCodeName)//, Symtable &symbolTable)
{
   setName(inCodeName, outCodeName);
   symbolTable.loadResvd();
   LN=1;
   TN=1;
   while(TN<255)
   {
      lineToke[TN][0] = 0;
      lineToke[TN][1] = 0;
      lineToke[TN][2] = 0;
      TN++;
   }
   TN=1;
	 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x13250
movq -0x78(%rbp), %rdi
movl $0x1, 0xc2c(%rdi)
addq $0xc30, %rdi            # imm = 0xC30
movq %rdi, -0x70(%rbp)
callq 0x2310
jmp 0x136ea
movq -0x78(%rbp), %rdi
addq $0xe30, %rdi            # imm = 0xE30
movq %rdi, -0xa0(%rbp)
callq 0x22a0
movq -0x78(%rbp), %rdi
addq $0xe50, %rdi            # imm = 0xE50
movq %rdi, -0x98(%rbp)
callq 0x22a0
movq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0x1372a
movq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x20d0
jmp 0x1373c
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x138a0
jmp 0x1374f
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x48(%rbp), %rdi
callq 0x2130
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x6dd0
jmp 0x13770
movq -0x78(%rbp), %rax
movl $0x1, 0xc28(%rax)
movl $0x1, 0xc2c(%rax)
movq -0x78(%rbp), %rax
cmpl $0xff, 0xc2c(%rax)
jge 0x1384e
movq -0x78(%rbp), %rax
movq %rax, %rcx
addq $0x28, %rcx
movslq 0xc2c(%rax), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0x0, (%rcx)
movq %rax, %rcx
addq $0x28, %rcx
movslq 0xc2c(%rax), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0x0, 0x4(%rcx)
movq %rax, %rcx
addq $0x28, %rcx
movslq 0xc2c(%rax), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0x0, 0x8(%rcx)
movl 0xc2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc2c(%rax)
jmp 0x13788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x13886
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x13865
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x13843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x48(%rbp), %rdi
callq 0x2130
jmp 0x13865
movq -0x78(%rbp), %rax
movl $0x1, 0xc2c(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x2130
movq -0xa0(%rbp), %rdi
callq 0x2130
movq -0x70(%rbp), %rdi
callq 0x22d0
movq -0x80(%rbp), %rdi
callq 0x5970
movq -0x20(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::isAlpha(char)
bool Scanner::isAlpha (char a)
{
   if(a>=65)
   {
      if(a<=90)
      {
	 return true;
      }
      if(a>=97)
      {
	 if(a<=122)
	 {
	    return true;
	 }
      }
   }
   return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x41, %eax
jl 0x13962
movsbl -0x11(%rbp), %eax
cmpl $0x5a, %eax
jg 0x13946
movb $0x1, -0x1(%rbp)
jmp 0x13966
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jl 0x13960
movsbl -0x11(%rbp), %eax
cmpl $0x7a, %eax
jg 0x1395e
movb $0x1, -0x1(%rbp)
jmp 0x13966
jmp 0x13960
jmp 0x13962
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::isNumeric(char)
bool Scanner::isNumeric (char a)
{ 
   switch(a)
   {
      case '1':
	 return true;
      case '2':
	 return true;
      case '3':
	 return true;
      case '4':
	 return true;
      case '5':
	 return true;
      case '6':
	 return true;
      case '7':
	 return true;
      case '8':
	 return true;
      case '9':
	 return true;
      case '0':
	 return true;
      default:
	 return false;
   } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x9, %eax
ja 0x139e0
movq -0x20(%rbp), %rax
leaq 0xbae1(%rip), %rcx      # 0x1f47c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x1, -0x1(%rbp)
jmp 0x139e4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)