LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ATOMIC-LICHESS[P]ATOMKRAFT/./tt.h
// Function: TTEntry::save(unsigned int, Value, ValueType, Depth, Move, int, Value, Value)
void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {

    key32        = (uint32_t)k;
    move16       = (uint16_t)m;
    valueType    = (uint8_t)t;
    generation8  = (uint8_t)g;
    value16      = (int16_t)v;
    depth16      = (int16_t)d;
    staticValue  = (int16_t)statV;
    staticMargin = (int16_t)statM;
  }

// Assembly:
movl 0x18(%rsp), %eax
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, (%rax)
movl -0x1c(%rsp), %ecx
movw %cx, 0x4(%rax)
movl -0x14(%rsp), %ecx
movb %cl, 0x6(%rax)
movl 0x8(%rsp), %ecx
movb %cl, 0x7(%rax)
movl -0x10(%rsp), %ecx
movw %cx, 0x8(%rax)
movl -0x18(%rsp), %ecx
movw %cx, 0xa(%rax)
movl 0x10(%rsp), %ecx
movw %cx, 0xc(%rax)
movl 0x18(%rsp), %ecx
movw %cx, 0xe(%rax)
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/tuning.cpp
// Function: VarTuning::rand_unit_vector(double*, int)
void VarTuning::rand_unit_vector(tune_t* vector, int size) {
	
	double norm;
	int64_t s = 0;
	int64_t ran;
	
	for (int k = 0; k < size; ++k) {
		ran = rkiss.rand<unsigned>() % 16777216;
		ran *= (rkiss.rand<unsigned>() % 2 ? 1 : -1);
		vector[k] = tune_t(ran);
		s += (ran * ran);
	}
	
	norm = sqrt(s);

	for (int k = 0; k < size; ++k) {
		vector[k] /= norm;
		cout << vector[k] << endl;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x519b6
movq 0x8(%rsp), %rdi
addq $0x29cc8, %rdi          # imm = 0x29CC8
callq 0xf600
movq 0x8(%rsp), %rdi
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, %eax
movq %rax, 0x18(%rsp)
addq $0x29cc8, %rdi          # imm = 0x29CC8
callq 0xf600
movl %eax, %edx
andl $0x1, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cltq
imulq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
cvtsi2sdq 0x18(%rsp), %xmm0
movq 0x38(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
imulq 0x18(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5191d
movq 0x20(%rsp), %rdi
callq 0x52480
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x51a2d
movsd 0x28(%rsp), %xmm1
movq 0x38(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x38(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1a5ac(%rip), %rdi     # 0x6bfb8
callq 0x6a10
movq %rax, %rdi
movq 0x1a575(%rip), %rsi     # 0x6bf90
callq 0x6520
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x519ce
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/tuning.cpp
// Function: VarTuning::prepare_deltas()
void VarTuning::prepare_deltas() {
	double norm;
	int64_t s = 0;
	int64_t ran;
	
	for (int k = 0; k < size; ++k) {
		ran = rkiss.rand<unsigned>() % 16777216;
		ran *= (rkiss.rand<unsigned>() % 2 ? 1 : -1);
		var[k].delta = tune_t(ran);
		s += (ran * ran);
	}
	
	norm = sqrt(s);
	
	// normalize
	for (int k = 0; k < size; ++k) {
		var[k].delta *= (var[k].startvalue * var[k].deltaAxisFactor / norm);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x29cc0(%rcx), %eax
jge 0x51dff
movq 0x8(%rsp), %rdi
addq $0x29cc8, %rdi          # imm = 0x29CC8
callq 0xf600
movq 0x8(%rsp), %rdi
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, %eax
movq %rax, 0x18(%rsp)
addq $0x29cc8, %rdi          # imm = 0x29CC8
callq 0xf600
movl %eax, %esi
movq 0x8(%rsp), %rax
andl $0x1, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rcx
imulq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rsp)
cvtsi2sdq 0x18(%rsp), %xmm0
movslq 0x14(%rsp), %rcx
imulq $0x6b0, %rcx, %rcx      # imm = 0x6B0
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movq 0x18(%rsp), %rax
imulq 0x18(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x51d54
movq 0x20(%rsp), %rdi
callq 0x52480
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x29cc0(%rcx), %eax
jge 0x51e87
movq 0x8(%rsp), %rax
movslq 0x10(%rsp), %rcx
imulq $0x6b0, %rcx, %rdx      # imm = 0x6B0
movq %rax, %rcx
addq %rdx, %rcx
movsd 0x10(%rcx), %xmm0
movslq 0x10(%rsp), %rcx
imulq $0x6b0, %rcx, %rdx      # imm = 0x6B0
movq %rax, %rcx
addq %rdx, %rcx
mulsd 0x28(%rcx), %xmm0
divsd 0x28(%rsp), %xmm0
movslq 0x10(%rsp), %rcx
imulq $0x6b0, %rcx, %rcx      # imm = 0x6B0
addq %rcx, %rax
mulsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x51e17
addq $0x38, %rsp
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/uci.cpp
// Function: (anonymous namespace)::perft(Position&, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>&)
void perft(Position& pos, UCIParser& up) {

    int depth, time;
    int64_t n;

    if (!(up >> depth))
        return;

    time = get_system_time();

    n = perft(pos, depth * ONE_PLY);

    time = get_system_time() - time;

    std::cout << "\nNodes " << n
              << "\nTime (ms) " << time
              << "\nNodes/second " << int(n / (time / 1000.0)) << std::endl;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x62c0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x6220
testb $0x1, %al
jne 0x53832
jmp 0x53837
jmp 0x538fa
callq 0x2c170
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
movl $0x2, %esi
callq 0x34660
movq (%rsp), %rdi
movl %eax, %esi
callq 0x40a30
movq %rax, 0x8(%rsp)
callq 0x2c170
movslq 0x10(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x10(%rsp)
movq 0x18739(%rip), %rdi     # 0x6bfb8
leaq 0x865c(%rip), %rsi      # 0x5bee2
callq 0x64b0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x69e0
movq %rax, %rdi
leaq 0x8648(%rip), %rsi      # 0x5beea
callq 0x64b0
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x6940
movq %rax, %rdi
leaq 0x8639(%rip), %rsi      # 0x5bef6
callq 0x64b0
movq %rax, %rdi
cvtsi2sdq 0x8(%rsp), %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
movsd 0x84ee(%rip), %xmm2     # 0x5bdc8
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
callq 0x6940
movq %rax, %rdi
movq 0x1869b(%rip), %rsi     # 0x6bf90
callq 0x6520
addq $0x28, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/ucioption.cpp
// Function: CaseInsensitiveLess::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {

  int c1, c2;
  size_t i = 0;

  while (i < s1.size() && i < s2.size())
  {
      c1 = tolower(s1[i]);
      c2 = tolower(s2[i++]);

      if (c1 != c2)
          return c1 < c2;
  }
  return s1.size() < s2.size();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x6330
movq 0x18(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x27(%rsp)
jae 0x53a99
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6330
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x53aa3
jmp 0x53b07
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6570
movsbl (%rax), %edi
callq 0x6770
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
callq 0x6570
movsbl (%rax), %edi
callq 0x6770
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
je 0x53b02
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
setl %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x53b34
jmp 0x53a4c
movq 0x40(%rsp), %rdi
callq 0x6330
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6330
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/ucioption.cpp
// Function: UCIOption::set_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void UCIOption::set_value(const string& v) {

  assert(!type.empty());

  if (v.empty())
      return;

  if ((type == "check" || type == "button") != (v == "true" || v == "false"))
      return;

  if (type == "spin")
  {
      int val = atoi(v.c_str());
      if (val < minValue || val > maxValue)
          return;
  }

  currentValue = v;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x68c0
testb $0x1, %al
jne 0x56738
jmp 0x5673d
jmp 0x5682e
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
leaq 0x57b8(%rip), %rsi      # 0x5bf05
callq 0x28180
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x56778
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
leaq 0x57aa(%rip), %rsi      # 0x5bf19
callq 0x28180
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
leaq 0x37cf(%rip), %rsi      # 0x59f5f
callq 0x28180
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x567b7
movq 0x18(%rsp), %rdi
leaq 0x4b0c(%rip), %rsi      # 0x5b2ba
callq 0x28180
movb %al, 0x6(%rsp)
movl (%rsp), %eax
movb 0x6(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x567ca
jmp 0x5682e
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
leaq 0x5765(%rip), %rsi      # 0x5bf3f
callq 0x28180
testb $0x1, %al
jne 0x567e5
jmp 0x5681b
movq 0x18(%rsp), %rdi
callq 0x61d0
movq %rax, %rdi
callq 0x67f0
movq 0x8(%rsp), %rcx
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x60(%rcx), %eax
jl 0x56817
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x64(%rcx), %eax
jle 0x56819
jmp 0x5682e
jmp 0x5681b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x20, %rdi
callq 0x6060
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Distrotech[P]stund/client.cxx
// Function: usage()
void
usage()
{
   cerr << "Usage:" << endl
	<< "    ./client stunServerHostname [testNumber] [-v] [-p srcPort] [-i nicAddr1] [-i nicAddr2] [-i nicAddr3]" << endl
	<< "For example, if the STUN server was larry.gloo.net, you could do:" << endl
	<< "    ./client larry.gloo.net" << endl
	<< "The testNumber is just used for special tests." << endl
	<< " test 1 runs test 1 from the RFC. For example:" << endl
	<< "    ./client larry.gloo.net 0" << endl << endl
        << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xbad5(%rip), %rdi      # 0xdff0
leaq 0x7b06(%rip), %rsi      # 0xa028
callq 0x21f0
movq %rax, %rdi
movq 0xba8f(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
leaq 0x7aef(%rip), %rsi      # 0xa02f
callq 0x21f0
movq %rax, %rdi
movq 0xba71(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
leaq 0x7b3a(%rip), %rsi      # 0xa098
callq 0x21f0
movq %rax, %rdi
movq 0xba53(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
leaq 0x7b5e(%rip), %rsi      # 0xa0da
callq 0x21f0
movq %rax, %rdi
movq 0xba35(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
leaq 0x7b5c(%rip), %rsi      # 0xa0f6
callq 0x21f0
movq %rax, %rdi
movq 0xba17(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
leaq 0x7b6d(%rip), %rsi      # 0xa125
callq 0x21f0
movq %rax, %rdi
movq 0xb9f9(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
leaq 0x7b7e(%rip), %rsi      # 0xa154
callq 0x21f0
movq %rax, %rdi
movq 0xb9db(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
movq 0xb9cc(%rip), %rsi      # 0xdfc0
callq 0x2200
movq %rax, %rdi
movq 0xb9bd(%rip), %rsi      # 0xdfc0
callq 0x2200
popq %rbp
retq
nopw (%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseAtrAddress(char*, unsigned int, StunAtrAddress4&)
static bool 
stunParseAtrAddress( char* body, unsigned int hdrLen,  StunAtrAddress4& result )
{
   if ( hdrLen != 8 )
   {
      clog << "hdrLen wrong for Address" <<endl;
      return false;
   }
   result.pad = *body++;
   result.family = *body++;
   if (result.family == IPv4Family)
   {
      UInt16 nport;
      memcpy(&nport, body, 2); body+=2;
      result.ipv4.port = ntohs(nport);
		
      UInt32 naddr;
      memcpy(&naddr, body, 4); body+=4;
      result.ipv4.addr = ntohl(naddr);
      return true;
   }
   else if (result.family == IPv6Family)
   {
      clog << "ipv6 not supported" << endl;
   }
   else
   {
      clog << "bad address family: " << result.family << endl;
   }
	
   return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x8, -0x14(%rbp)
je 0x3f34
movq 0xa0a0(%rip), %rdi      # 0xdfb0
leaq 0x7314(%rip), %rsi      # 0xb22b
callq 0x21f0
movq %rax, %rdi
movq 0xa09a(%rip), %rsi      # 0xdfc0
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x4030
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x3fc7
movq -0x10(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movzwl -0x22(%rbp), %edi
callq 0x2330
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movl -0x28(%rbp), %edi
callq 0x2250
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4030
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x2, %eax
jne 0x3ff8
movq 0x9fd5(%rip), %rdi      # 0xdfb0
leaq 0x7262(%rip), %rsi      # 0xb244
callq 0x21f0
movq %rax, %rdi
movq 0x9fcf(%rip), %rsi      # 0xdfc0
callq 0x2200
jmp 0x402a
movq 0x9fb1(%rip), %rdi      # 0xdfb0
leaq 0x7251(%rip), %rsi      # 0xb257
callq 0x21f0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x22c0
movq %rax, %rdi
movq 0x9f9b(%rip), %rsi      # 0xdfc0
callq 0x2200
jmp 0x402c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: operator<<(std::ostream&, StunAddress4 const&)
ostream& 
operator<<( ostream& strm, const StunAddress4& addr)
{
   UInt32 ip = addr.addr;
   strm << ((int)(ip>>24)&0xFF) << ".";
   strm << ((int)(ip>>16)&0xFF) << ".";
   strm << ((int)(ip>> 8)&0xFF) << ".";
   strm << ((int)(ip>> 0)&0xFF) ;
	
   strm << ":" << addr.port;
	
   return strm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
shrl $0x18, %esi
andl $0xff, %esi
callq 0x2300
movq %rax, %rdi
leaq 0x6c1d(%rip), %rsi      # 0xac96
callq 0x21f0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
shrl $0x10, %esi
andl $0xff, %esi
callq 0x2300
movq %rax, %rdi
leaq 0x6bf9(%rip), %rsi      # 0xac96
callq 0x21f0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
callq 0x2300
movq %rax, %rdi
leaq 0x6bd5(%rip), %rsi      # 0xac96
callq 0x21f0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
shrl $0x0, %esi
andl $0xff, %esi
callq 0x2300
movq -0x8(%rbp), %rdi
leaq 0x6bc2(%rip), %rsi      # 0xaca8
callq 0x21f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movzwl (%rax), %esi
callq 0x22f0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseAtrChangeRequest(char*, unsigned int, StunAtrChangeRequest&)
static bool 
stunParseAtrChangeRequest( char* body, unsigned int hdrLen,  StunAtrChangeRequest& result )
{
   if ( hdrLen != 4 )
   {
      clog << "hdr length = " << hdrLen << " expecting " << sizeof(result) << endl;
		
      clog << "Incorrect size for ChangeRequest" << endl;
      return false;
   }
   else
   {
      memcpy(&result.value, body, 4);
      result.value = ntohl(result.value);
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x4, -0x14(%rbp)
je 0x419a
movq 0x9e80(%rip), %rdi      # 0xdfb0
leaq 0x7135(%rip), %rsi      # 0xb26c
callq 0x21f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2260
movq %rax, %rdi
leaq 0x7129(%rip), %rsi      # 0xb27a
callq 0x21f0
movq %rax, %rdi
movl $0x4, %esi
callq 0x2090
movq %rax, %rdi
movq 0x9e53(%rip), %rsi      # 0xdfc0
callq 0x2200
movq 0x9e37(%rip), %rdi      # 0xdfb0
leaq 0x7106(%rip), %rsi      # 0xb286
callq 0x21f0
movq %rax, %rdi
movq 0x9e31(%rip), %rsi      # 0xdfc0
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x41bd
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x2250
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseAtrString(char*, unsigned int, StunAtrString&)
static bool 
stunParseAtrString( char* body, unsigned int hdrLen,  StunAtrString& result )
{
   if ( hdrLen >= STUN_MAX_STRING )
   {
      clog << "String is too large" << endl;
      return false;
   }
   else
   {
      if (hdrLen % 4 != 0)
      {
         clog << "Bad length string " << hdrLen << endl;
         return false;
      }
		
      result.sizeValue = hdrLen;
      memcpy(&result.value, body, hdrLen);
      result.value[hdrLen] = 0;
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jb 0x4214
movq 0x9dbd(%rip), %rdi      # 0xdfb0
leaq 0x70ad(%rip), %rsi      # 0xb2a7
callq 0x21f0
movq %rax, %rdi
movq 0x9db7(%rip), %rsi      # 0xdfc0
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x4284
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x4252
movq 0x9d8a(%rip), %rdi      # 0xdfb0
leaq 0x708e(%rip), %rsi      # 0xb2bb
callq 0x21f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2260
movq %rax, %rdi
movq 0x9d79(%rip), %rsi      # 0xdfc0
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x4284
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x100(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2190
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseAtrIntegrity(char*, unsigned int, StunAtrIntegrity&)
static bool 
stunParseAtrIntegrity( char* body, unsigned int hdrLen,  StunAtrIntegrity& result )
{
   if ( hdrLen != 20)
   {
      clog << "MessageIntegrity must be 20 bytes" << endl;
      return false;
   }
   else
   {
      memcpy(&result.hash, body, hdrLen);
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x14, -0x14(%rbp)
je 0x42d1
movq 0x9d00(%rip), %rdi      # 0xdfb0
leaq 0x7017(%rip), %rsi      # 0xb2ce
callq 0x21f0
movq %rax, %rdi
movq 0x9cfa(%rip), %rsi      # 0xdfc0
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x42e7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseAtrError(char*, unsigned int, StunAtrError&)
static bool 
stunParseAtrError( char* body, unsigned int hdrLen,  StunAtrError& result )
{
   if ( hdrLen >= sizeof(result) )
   {
      clog << "head on Error too large" << endl;
      return false;
   }
   else
   {
      memcpy(&result.pad, body, 2); body+=2;
      result.pad = ntohs(result.pad);
      result.errorClass = *body++;
      result.number = *body++;
		
      result.sizeReason = hdrLen - 4;
      memcpy(&result.reason, body, result.sizeReason);
      result.reason[result.sizeReason] = 0;
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x106, %rax            # imm = 0x106
jb 0x4349
movq 0x9c8b(%rip), %rdi      # 0xdfb0
leaq 0x6fc4(%rip), %rsi      # 0xb2f0
callq 0x21f0
movq %rax, %rdi
movq 0x9c85(%rip), %rsi      # 0xdfc0
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x43f3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %edi
callq 0x2330
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x14(%rbp), %eax
subl $0x4, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x104(%rax)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movzwl 0x104(%rax), %eax
movl %eax, %edx
callq 0x2190
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl 0x104(%rcx), %ecx
movb $0x0, 0x4(%rax,%rcx)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseAtrUnknown(char*, unsigned int, StunAtrUnknown&)
static bool 
stunParseAtrUnknown( char* body, unsigned int hdrLen,  StunAtrUnknown& result )
{
   if ( hdrLen >= sizeof(result) )
   {
      return false;
   }
   else
   {
      if (hdrLen % 4 != 0) return false;
      result.numAttributes = hdrLen / 4;
      for (int i=0; i<result.numAttributes; i++)
      {
         memcpy(&result.attrType[i], body, 2); body+=2;
         result.attrType[i] = ntohs(result.attrType[i]);
      }
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x12, %rax
jb 0x4425
movb $0x0, -0x1(%rbp)
jmp 0x44ab
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x4436
movb $0x0, -0x1(%rbp)
jmp 0x44ab
movl -0x14(%rbp), %eax
shrl $0x2, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x10(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x44a7
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq -0x10(%rbp), %rdx
movw (%rdx), %dx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %edi
callq 0x2330
movw %ax, %dx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x444e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: encodeAtrAddress4(char*, unsigned short, StunAtrAddress4 const&)
static char* 
encodeAtrAddress4(char* ptr, UInt16 type, const StunAtrAddress4& atr)
{
   ptr = encode16(ptr, type);
   ptr = encode16(ptr, 8);
   *ptr++ = atr.pad;
   *ptr++ = IPv4Family;
   ptr = encode16(ptr, atr.ipv4.port);
   ptr = encode32(ptr, atr.ipv4.addr);
	
   return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x8e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: encodeAtrChangeRequest(char*, StunAtrChangeRequest const&)
static char* 
encodeAtrChangeRequest(char* ptr, const StunAtrChangeRequest& atr)
{
   ptr = encode16(ptr, ChangeRequest);
   ptr = encode16(ptr, 4);
   ptr = encode32(ptr, atr.value);
   return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x8e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: encodeAtrString(char*, unsigned short, StunAtrString const&)
static char* 
encodeAtrString(char* ptr, UInt16 type, const StunAtrString& atr)
{
   assert(atr.sizeValue % 4 == 0);
	
   ptr = encode16(ptr, type);
   ptr = encode16(ptr, atr.sizeValue);
   ptr = encode(ptr, atr.value, atr.sizeValue);
   return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x100(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4d71
jmp 0x4d90
leaq 0x6590(%rip), %rdi      # 0xb308
leaq 0x59d6(%rip), %rsi      # 0xa755
movl $0x20b, %edx            # imm = 0x20B
leaq 0x6594(%rip), %rcx      # 0xb31f
callq 0x2140
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl 0x100(%rax), %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movzwl 0x100(%rax), %edx
callq 0x4c00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Distrotech[P]stund/stun.cxx
// Function: encodeAtrError(char*, StunAtrError const&)
static char* 
encodeAtrError(char* ptr, const StunAtrError& atr)
{
   ptr = encode16(ptr, ErrorCode);
   ptr = encode16(ptr, 6 + atr.sizeReason);
   ptr = encode16(ptr, atr.pad);
   *ptr++ = atr.errorClass;
   *ptr++ = atr.number;
   ptr = encode(ptr, atr.reason, atr.sizeReason);
   return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x104(%rax), %eax
addl $0x6, %eax
movzwl %ax, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl (%rax), %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rax
movzwl 0x104(%rax), %edx
callq 0x4c00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Distrotech[P]stund/stun.cxx
// Function: encodeAtrUnknown(char*, StunAtrUnknown const&)
static char* 
encodeAtrUnknown(char* ptr, const StunAtrUnknown& atr)
{
   ptr = encode16(ptr, UnknownAttribute);
   ptr = encode16(ptr, 2+2*atr.numAttributes);
   for (int i=0; i<atr.numAttributes; i++)
   {
      ptr = encode16(ptr, atr.attrType[i]);
   }
   return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
shll %eax
addl $0x2, %eax
movzwl %ax, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4f09
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ed6
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: encodeAtrIntegrity(char*, StunAtrIntegrity const&)
static char* 
encodeAtrIntegrity(char* ptr, const StunAtrIntegrity& atr)
{
   ptr = encode16(ptr, MessageIntegrity);
   ptr = encode16(ptr, 20);
   ptr = encode(ptr, atr.hash, sizeof(atr.hash));
   return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x14, %esi
callq 0x4bc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x14, %edx
callq 0x4c00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunRandomPort()
int
stunRandomPort()
{
   int min=0x4000;
   int max=0x7FFF;
	
   int ret = stunRand();
   ret = ret|min;
   ret = ret&max;
	
   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4000, -0x4(%rbp)     # imm = 0x4000
movl $0x7fff, -0x8(%rbp)     # imm = 0x7FFF
callq 0x4ff0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
orl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: toHex(char const*, int, char*)
static void
toHex(const char* buffer, int bufferSize, char* output) 
{
   static char hexmap[] = "0123456789abcdef";
	
   const char* p = buffer;
   char* r = output;
   for (int i=0; i < bufferSize; i++)
   {
      unsigned char temp = *p++;
		
      int hi = (temp & 0xf0)>>4;
      int low = (temp & 0xf);
		
      *r++ = hexmap[hi];
      *r++ = hexmap[low];
   }
   *r = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x53d4
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x2d(%rbp)
movzbl -0x2d(%rbp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movl %eax, -0x34(%rbp)
movzbl -0x2d(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x38(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x8e2a(%rip), %rax      # 0xe1c0
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movslq -0x38(%rbp), %rcx
leaq 0x8e0b(%rip), %rax      # 0xe1c0
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5356
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunCreatePassword(StunAtrString const&, StunAtrString*)
void
stunCreatePassword(const StunAtrString& username, StunAtrString* password)
{
   char hmac[20];
   char key[] = "Fluffy";
   //char buffer[STUN_MAX_STRING];
   computeHmac(hmac, username.value, strlen(username.value), key, strlen(key));
   toHex(hmac, 20, password->value);
   password->sizeValue = 40;
   password->value[40]=0;
	
   //clog << "password=" << password->value << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x5626(%rip), %eax      # 0xaa1c
movl %eax, -0x37(%rbp)
movw 0x5620(%rip), %ax       # 0xaa20
movw %ax, -0x33(%rbp)
movb 0x5618(%rip), %al       # 0xaa22
movb %al, -0x31(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
movl %eax, -0x44(%rbp)
leaq -0x37(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x37(%rbp), %rdi
callq 0x20e0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x44(%rbp), %edx
movq -0x40(%rbp), %rcx
movl %eax, %r8d
callq 0x4f50
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x14, %esi
callq 0x5330
movq -0x10(%rbp), %rax
movw $0x28, 0x100(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x28(%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Distrotech[P]stund/stun.cxx
// Function: operator<<(std::ostream&, UInt128 const&)
ostream& operator<< ( ostream& strm, const UInt128& r )
{
   strm << int(r.octet[0]);
   for ( int i=1; i<16; i++ )
   {
      strm << ':' << int(r.octet[i]);
   }
    
   return strm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
callq 0x2300
movl $0x1, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x54da
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
callq 0x2230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x2300
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54a7
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunParseServerName(char*, StunAddress4&)
bool
stunParseServerName( char* name, StunAddress4& addr)
{
   assert(name);
	
   // TODO - put in DNS SRV stuff.
	
   bool ret = stunParseHostName( name, addr.addr, addr.port, 3478); 
   if ( ret != true ) 
   {
       addr.port=0xFFFF;
   }	
   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x56d9
jmp 0x56f8
leaq 0x4ee5(%rip), %rdi      # 0xa5c5
leaq 0x506e(%rip), %rsi      # 0xa755
movl $0x3c5, %edx            # imm = 0x3C5
leaq 0x533b(%rip), %rcx      # 0xaa2e
callq 0x2140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
movl $0xd96, %ecx            # imm = 0xD96
callq 0x54f0
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x572d
movq -0x10(%rbp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunCreateSharedSecretResponse(StunMessage const&, StunAddress4 const&, StunMessage&)
static void
stunCreateSharedSecretResponse(const StunMessage& request, const StunAddress4& source, StunMessage& response)
{
   response.msgHdr.msgType = SharedSecretResponseMsg;
   response.msgHdr.id = request.msgHdr.id;
	
   response.hasUsername = true;
   stunCreateUserName( source, &response.username);
	
   response.hasPassword = true;
   stunCreatePassword( response.username, &response.password);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movw $0x102, (%rax)          # imm = 0x102
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x4(%rcx), %rdx
movq %rdx, 0x4(%rax)
movq 0xc(%rcx), %rcx
movq %rcx, 0xc(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x5c(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x5e, %rsi
callq 0x5090
movq -0x18(%rbp), %rax
movb $0x1, 0x160(%rax)
movq -0x18(%rbp), %rdi
addq $0x5e, %rdi
movq -0x18(%rbp), %rsi
addq $0x162, %rsi            # imm = 0x162
callq 0x53e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunCreateErrorResponse(StunMessage&, int, int, char const*)
static void
stunCreateErrorResponse(StunMessage& response, int cl, int number, const char* msg)
{
   response.msgHdr.msgType = BindErrorResponseMsg;
   response.hasErrorCode = true;
   response.errorCode.errorClass = cl;
   response.errorCode.number = number;
   strcpy(response.errorCode.reason, msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movw $0x111, (%rax)          # imm = 0x111
movq -0x8(%rbp), %rax
movb $0x1, 0x279(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x27c(%rax)
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x27d(%rax)
movq -0x8(%rbp), %rdi
addq $0x27a, %rdi            # imm = 0x27A
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
callq 0x21c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Distrotech[P]stund/stun.cxx
// Function: stunStopServer(StunServerInfo&)
void
stunStopServer(StunServerInfo& info)
{
   if (info.myFd > 0) closesocket(info.myFd);
   if (info.altPortFd > 0) closesocket(info.altPortFd);
   if (info.altIpFd > 0) closesocket(info.altIpFd);
   if (info.altIpPortFd > 0) closesocket(info.altIpPortFd);
   
   if (info.relay)
   {
      for (int i=0; i<MAX_MEDIA_RELAYS; ++i)
      {
         StunMediaRelay* relay = &info.relays[i];
         if (relay->fd)
         {
            closesocket(relay->fd);
            relay->fd = 0;
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x64c2
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x31c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x64d8
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x31c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x64ee
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x31c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x6504
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x31c0
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x6565
movl $0x0, -0xc(%rbp)
cmpl $0x1f4, -0xc(%rbp)      # imm = 0x1F4
jge 0x6563
movq -0x8(%rbp), %rax
addq $0x28, %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x6556
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x31c0
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x6558
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6515
jmp 0x6565
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2one(int*, unsigned long, std::function<void (int*)> const&) const
void parallel_mul2one(T* op1,
                          const size_t num_op1,
                          const std::function<void(T*)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&op1, &f](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&op1[ti]);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0xc0(%rsp), %rsi
callq 0xa8e0
movq 0x10(%rsp), %rdi
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0xa970
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa9f0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0xaa00
jmp 0xa723
leaq 0x8f(%rsp), %rdi
callq 0xaa80
movq $0x0, 0x70(%rsp)
movq 0x70(%rsp), %rax
cmpq 0xa8(%rsp), %rax
je 0xa848
leaq 0xc8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq 0xb0(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rax
incq %rax
movq 0xb0(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x48(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xaa90
movq %rax, 0x8(%rsp)
jmp 0xa7ae
movq 0x8(%rsp), %rcx
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xaad0
jmp 0xa7c9
movq 0x70(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xaba0
movq %rax, %rdi
leaq 0x68(%rsp), %rsi
callq 0xabc0
leaq 0x68(%rsp), %rdi
callq 0xac00
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0xa739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x8f(%rsp), %rdi
callq 0xaa80
jmp 0xa8c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xacf0
jmp 0xa8c6
leaq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xac20
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0xac50
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xac80
testb $0x1, %al
jne 0xa888
jmp 0xa8b1
leaq 0x38(%rsp), %rdi
callq 0xacc0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x96c0
jmp 0xa8a3
jmp 0xa8a5
leaq 0x38(%rsp), %rdi
callq 0xacd0
jmp 0xa873
leaq 0x90(%rsp), %rdi
callq 0xacf0
addq $0xd8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::get_block_size(unsigned long) const
inline size_t get_block_size(const size_t size) const{
        size_t block_size = size / _num_thread;
        if( size % _num_thread != 0){
            block_size += 1;
        }
        return block_size < _min_block_size ? std::min(size, _min_block_size) : block_size;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
xorl %edx, %edx
divq (%rcx)
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
xorl %edx, %edx
divq (%rcx)
cmpq $0x0, %rdx
je 0xa925
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0xa951
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x18(%rsp), %rdi
callq 0xaa90
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0xa95a
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::get_num_thread(unsigned long, unsigned long) const
inline size_t get_num_thread(const size_t size, const size_t block_size) const{
        if(block_size > _min_block_size){
            return _num_thread;
        }
        size_t num_thread = size / block_size;
        if(size % block_size != 0){
            num_thread += 1;
        }
        return num_thread;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x30(%rsp)
movq -0x20(%rsp), %rax
cmpq 0x8(%rcx), %rax
jbe 0xa9a3
movq -0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xa9e2
movq -0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rsp)
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rsp)
cmpq $0x0, %rdx
je 0xa9d8
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: btbujiangjun[P]abcdl/include/utils/ParallelOperator.h
// Function: abcdl::utils::ParallelOperator<int>::parallel_mul2one(int*, unsigned long, int const&, std::function<void (int*, int const&)> const&) const
void parallel_mul2one(T* op1,
                          const size_t num_op1,
                          const T& op2,
                          const std::function<void(T*, const T&)> &f) const{
        size_t block_size = get_block_size(num_op1);
        size_t num_thread = get_num_thread(num_op1, block_size);
        std::vector<std::thread> threads(num_thread);

        for(size_t i = 0; i != num_thread; i++){
            threads[i] = std::thread(
                [&op1, &op2, &f](size_t start_idx, size_t end_idx){
                    for(size_t ti = start_idx; ti != end_idx; ti++){
                        f(&op1[ti], op2);
                    }
                }, i * block_size, std::min(num_op1, (i + 1) * block_size)
            );
        }

        for(auto& thread : threads){
            thread.join();
        }
    }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0xd0(%rsp), %rsi
callq 0xa8e0
movq 0x10(%rsp), %rdi
movq %rax, 0xb8(%rsp)
movq 0xd0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0xa970
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x97(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa9f0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x98(%rsp), %rdi
callq 0xaa00
jmp 0xadfb
leaq 0x97(%rsp), %rdi
callq 0xaa80
movq $0x0, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0xb0(%rsp), %rax
je 0xaf33
leaq 0xd8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq 0xb8(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
incq %rax
movq 0xb8(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x48(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xaa90
movq %rax, 0x8(%rsp)
jmp 0xae93
movq 0x8(%rsp), %rcx
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xafc0
jmp 0xaeae
movq 0x78(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0xaba0
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0xabc0
leaq 0x70(%rsp), %rdi
callq 0xac00
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xae11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x97(%rsp), %rdi
callq 0xaa80
jmp 0xafb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xacf0
jmp 0xafb1
leaq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xac20
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0xac50
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xac80
testb $0x1, %al
jne 0xaf73
jmp 0xaf9c
leaq 0x38(%rsp), %rdi
callq 0xacc0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x96c0
jmp 0xaf8e
jmp 0xaf90
leaq 0x38(%rsp), %rdi
callq 0xacd0
jmp 0xaf5e
leaq 0x98(%rsp), %rdi
callq 0xacf0
addq $0xe8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x9700
nop