// File: /workspace/github_cpp_makefile_star2_O2/Distrotech[P]stund/stun.cxx
// Function: stunParseMessage(char*, unsigned int, StunMessage&, bool)
bool
stunParseMessage( char* buf, unsigned int bufLen, StunMessage& msg, bool verbose)
{
   if (verbose) clog << "Received stun message: " << bufLen << " bytes" << endl;
   memset(&msg, 0, sizeof(msg));
	
   if (sizeof(StunMsgHdr) > bufLen)
   {
      clog << "Bad message" << endl;
      return false;
   }
	
   memcpy(&msg.msgHdr, buf, sizeof(StunMsgHdr));
   msg.msgHdr.msgType = ntohs(msg.msgHdr.msgType);
   msg.msgHdr.msgLength = ntohs(msg.msgHdr.msgLength);
	
   if (msg.msgHdr.msgLength + sizeof(StunMsgHdr) != bufLen)
   {
      clog << "Message header length doesn't match message size: "
           << msg.msgHdr.msgLength << " - " << bufLen << endl;
      return false;
   }
	
   char* body = buf + sizeof(StunMsgHdr);
   unsigned int size = msg.msgHdr.msgLength;
	
   //clog << "bytes after header = " << size << endl;
	
   while ( size > 0 )
   {
      // !jf! should check that there are enough bytes left in the buffer
		
      StunAtrHdr* attr = reinterpret_cast<StunAtrHdr*>(body);
		
      unsigned int attrLen = ntohs(attr->length);
      int atrType = ntohs(attr->type);
		
      //if (verbose) clog << "Found attribute type=" << AttrNames[atrType] << " length=" << attrLen << endl;
      if ( attrLen+4 > size ) 
      {
         clog << "claims attribute is larger than size of message " 
              <<"(attribute type="<<atrType<<")"<< endl;
         return false;
      }
		
      body += 4; // skip the length and type in attribute header
      size -= 4;
		
      switch ( atrType )
      {
         case MappedAddress:
            msg.hasMappedAddress = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.mappedAddress )== false )
            {
               clog << "problem parsing MappedAddress" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "MappedAddress = " << msg.mappedAddress.ipv4 << endl;
            }
					
            break;  

         case ResponseAddress:
            msg.hasResponseAddress = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.responseAddress )== false )
            {
               clog << "problem parsing ResponseAddress" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "ResponseAddress = " << msg.responseAddress.ipv4 << endl;
            }
            break;  
				
         case ChangeRequest:
            msg.hasChangeRequest = true;
            if (stunParseAtrChangeRequest( body, attrLen, msg.changeRequest) == false)
            {
               clog << "problem parsing ChangeRequest" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "ChangeRequest = " << msg.changeRequest.value << endl;
            }
            break;
				
         case SourceAddress:
            msg.hasSourceAddress = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.sourceAddress )== false )
            {
               clog << "problem parsing SourceAddress" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "SourceAddress = " << msg.sourceAddress.ipv4 << endl;
            }
            break;  
				
         case ChangedAddress:
            msg.hasChangedAddress = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.changedAddress )== false )
            {
               clog << "problem parsing ChangedAddress" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "ChangedAddress = " << msg.changedAddress.ipv4 << endl;
            }
            break;  
				
         case Username: 
            msg.hasUsername = true;
            if (stunParseAtrString( body, attrLen, msg.username) == false)
            {
               clog << "problem parsing Username" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "Username = " << msg.username.value << endl;
            }
					
            break;
				
         case Password: 
            msg.hasPassword = true;
            if (stunParseAtrString( body, attrLen, msg.password) == false)
            {
               clog << "problem parsing Password" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "Password = " << msg.password.value << endl;
            }
            break;
				
         case MessageIntegrity:
            msg.hasMessageIntegrity = true;
            if (stunParseAtrIntegrity( body, attrLen, msg.messageIntegrity) == false)
            {
               clog << "problem parsing MessageIntegrity" << endl;
               return false;
            }
            else
            {
               //if (verbose) clog << "MessageIntegrity = " << msg.messageIntegrity.hash << endl;
            }
					
            // read the current HMAC
            // look up the password given the user of given the transaction id 
            // compute the HMAC on the buffer
            // decide if they match or not
            break;
				
         case ErrorCode:
            msg.hasErrorCode = true;
            if (stunParseAtrError(body, attrLen, msg.errorCode) == false)
            {
               clog << "problem parsing ErrorCode" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "ErrorCode = " << int(msg.errorCode.errorClass) 
                                 << " " << int(msg.errorCode.number) 
                                 << " " << msg.errorCode.reason << endl;
            }
					
            break;
				
         case UnknownAttribute:
            msg.hasUnknownAttributes = true;
            if (stunParseAtrUnknown(body, attrLen, msg.unknownAttributes) == false)
            {
               clog << "problem parsing UnknownAttribute" << endl;
               return false;
            }
            break;
				
         case ReflectedFrom:
            msg.hasReflectedFrom = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.reflectedFrom ) == false )
            {
               clog << "problem parsing ReflectedFrom" << endl;
               return false;
            }
            break;  
				
         case XorMappedAddress:
            msg.hasXorMappedAddress = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.xorMappedAddress ) == false )
            {
               clog << "problem parsing XorMappedAddress" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "XorMappedAddress = " << msg.mappedAddress.ipv4 << endl;
            }
            break;  

         case XorOnly:
            msg.xorOnly = true;
            if (verbose) 
            {
               clog << "xorOnly = true" << endl;
            }
            break;  
				
         case ServerName: 
            msg.hasServerName = true;
            if (stunParseAtrString( body, attrLen, msg.serverName) == false)
            {
               clog << "problem parsing ServerName" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "ServerName = " << msg.serverName.value << endl;
            }
            break;
				
         case SecondaryAddress:
            msg.hasSecondaryAddress = true;
            if ( stunParseAtrAddress(  body,  attrLen,  msg.secondaryAddress ) == false )
            {
               clog << "problem parsing secondaryAddress" << endl;
               return false;
            }
            else
            {
               if (verbose) clog << "SecondaryAddress = " << msg.secondaryAddress.ipv4 << endl;
            }
            break;  
					
         default:
            if (verbose) clog << "Unknown attribute: " << atrType << endl;
            if ( atrType <= 0x7FFF ) 
            {
               return false;
            }
      }
		
      body += attrLen;
      size -= attrLen;
   }
    
   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r14d
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
je 0x2dad
movq 0x8239(%rip), %rdi      # 0xafb8
leaq 0x46a6(%rip), %rsi      # 0x742c
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
leaq 0x54d1(%rip), %rsi      # 0x826e
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
movl $0x4c8, %edx            # imm = 0x4C8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2110
cmpl $0x13, %ebp
ja 0x2dd9
movq 0x81f0(%rip), %rdi      # 0xafb8
leaq 0x4675(%rip), %rsi      # 0x7444
callq 0x21d0
jmp 0x34c5
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movl 0x10(%r15), %eax
rolw $0x8, (%rbx)
movl %eax, 0x10(%rbx)
movzwl 0x2(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
movzwl %ax, %r8d
leal 0x14(%r8), %eax
cmpl %ebp, %eax
jne 0x348c
addq $0x14, %r15
leaq 0x4bc(%rbx), %rax
movq %rax, 0xa0(%rsp)
leaq 0x4c0(%rbx), %rax
movq %rax, 0x60(%rsp)
leaq 0x3b6(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x3a8(%rbx), %rax
movq %rax, 0x98(%rsp)
leaq 0x1c(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x398(%rbx), %rax
movq %rax, 0x90(%rsp)
leaq 0x27e(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x265(%rbx), %rax
movq %rax, 0x68(%rsp)
leaq 0x162(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x5e(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x50(%rbx), %rax
movq %rax, 0x88(%rsp)
leaq 0x54(%rbx), %rax
movq %rax, 0x58(%rsp)
leaq 0x40(%rbx), %rax
movq %rax, 0x80(%rsp)
leaq 0x44(%rbx), %rax
movq %rax, 0x50(%rsp)
leaq 0x28(%rbx), %rax
movq %rax, 0x78(%rsp)
leaq 0x2c(%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0x18(%rbx), %rax
movq %rax, 0x70(%rsp)
testl %r8d, %r8d
sete %bpl
je 0x34cf
movzwl (%r15), %r14d
movzwl 0x2(%r15), %eax
movl %eax, %ecx
rolw $0x8, %cx
rolw $0x8, %r14w
movzwl %cx, %esi
movzwl %r14w, %r13d
leal 0x4(%rsi), %edx
cmpl %r8d, %edx
ja 0x34e3
leaq 0x4(%r15), %r12
leal -0x1(%r13), %edx
movl %esi, %edi
movq %rdi, 0x40(%rsp)
cmpl $0xa, %edx
movq %r8, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
ja 0x2f6e
leaq 0x44b0(%rip), %rdi      # 0x73d4
movslq (%rdi,%rdx,4), %rdx
addq %rdi, %rdx
jmpq *%rdx
movb $0x1, 0x14(%rbx)
movq %r12, %rdi
movq 0x70(%rsp), %rdx
callq 0x36ac
testb %al, %al
je 0x3620
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x8056(%rip), %rdi      # 0xafb8
leaq 0x4735(%rip), %rsi      # 0x769e
jmp 0x3267
cmpl $0x21, %r13d
je 0x309d
cmpl $0x8020, %r13d          # imm = 0x8020
je 0x3225
cmpl $0x8022, %r13d          # imm = 0x8022
je 0x3107
cmpl $0x8050, %r13d          # imm = 0x8050
jne 0x3284
movb $0x1, 0x4b8(%rbx)
movq %r12, %rdi
movq 0xa0(%rsp), %rdx
callq 0x36ac
testb %al, %al
je 0x3646
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7fde(%rip), %rdi      # 0xafb8
leaq 0x4727(%rip), %rsi      # 0x7708
callq 0x21d0
movq %rax, %r15
movq %rax, %rdi
movq 0x60(%rsp), %rsi
jmp 0x3277
movb $0x1, 0x4c(%rbx)
movq %r12, %rdi
movq 0x88(%rsp), %rdx
callq 0x36ac
testb %al, %al
je 0x360d
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7f8a(%rip), %rdi      # 0xafb8
leaq 0x4562(%rip), %rsi      # 0x7597
callq 0x21d0
movq %rax, %r15
movq %rax, %rdi
movq 0x58(%rsp), %rsi
jmp 0x3277
movb $0x1, 0x380(%rbx)
cmpw $0x11, %cx
ja 0x3699
movl %esi, %eax
andl $0x3, %eax
jne 0x3699
movl %esi, %ecx
shrl $0x2, %ecx
movw %cx, 0x392(%rbx)
xorl %eax, %eax
movzwl %cx, %ecx
cmpq %rcx, %rax
jae 0x3478
movzwl (%r12,%rax,2), %ecx
rolw $0x8, %cx
movw %cx, 0x382(%rbx,%rax,2)
incq %rax
movzwl 0x392(%rbx), %ecx
jmp 0x3074
movb $0x1, 0x3b4(%rbx)
cmpb $0x0, 0x4(%rsp)
je 0x3478
movq 0x7f02(%rip), %rdi      # 0xafb8
leaq 0x45f2(%rip), %rsi      # 0x76af
jmp 0x3461
movb $0x1, 0x34(%rbx)
cmpw $0x400, %ax             # imm = 0x400
jne 0x3558
movl (%r12), %eax
bswapl %eax
movl %eax, 0x38(%rbx)
cmpb $0x0, 0x4(%rsp)
je 0x3478
movq 0x7ecd(%rip), %rdi      # 0xafb8
leaq 0x4446(%rip), %rsi      # 0x7538
callq 0x21d0
movl 0x38(%rbx), %esi
movq %rax, %rdi
callq 0x2130
jmp 0x3466
movb $0x1, 0x3b5(%rbx)
movq %r12, %rdi
movq 0x38(%rsp), %rdx
callq 0x37cf
testb %al, %al
je 0x3633
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7e79(%rip), %rdi      # 0xafb8
leaq 0x4593(%rip), %rsi      # 0x76d9
callq 0x21d0
movq %rax, %rdi
movq 0x38(%rsp), %rsi
jmp 0x3461
movb $0x1, 0x3c(%rbx)
movq %r12, %rdi
movq 0x80(%rsp), %rdx
callq 0x36ac
testb %al, %al
je 0x351f
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7e28(%rip), %rdi      # 0xafb8
leaq 0x43d0(%rip), %rsi      # 0x7567
callq 0x21d0
movq %rax, %r15
movq %rax, %rdi
movq 0x50(%rsp), %rsi
jmp 0x3277
movb $0x1, 0x264(%rbx)
cmpw $0x1400, %ax            # imm = 0x1400
jne 0x3659
movl 0x10(%r12), %eax
movq 0x68(%rsp), %rcx
movl %eax, 0x10(%rcx)
movups (%r12), %xmm0
movups %xmm0, (%rcx)
jmp 0x3478
movb $0x1, 0x24(%rbx)
movq %r12, %rdi
movq 0x78(%rsp), %rdx
callq 0x36ac
testb %al, %al
je 0x3686
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7dac(%rip), %rdi      # 0xafb8
leaq 0x42f4(%rip), %rsi      # 0x7507
callq 0x21d0
movq %rax, %r15
movq %rax, %rdi
movq 0x48(%rsp), %rsi
jmp 0x3277
movb $0x1, 0x3a4(%rbx)
movq %r12, %rdi
movq 0x98(%rsp), %rdx
callq 0x36ac
testb %al, %al
je 0x35c0
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7d58(%rip), %rdi      # 0xafb8
leaq 0x4434(%rip), %rsi      # 0x769b
callq 0x21d0
movq %rax, %r15
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x3732
movq %r15, %rdi
jmp 0x3469
cmpb $0x0, 0x4(%rsp)
je 0x32bb
movq 0x7d26(%rip), %rdi      # 0xafb8
leaq 0x4483(%rip), %rsi      # 0x771c
callq 0x21d0
movq %rax, %rdi
movl %r13d, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20c0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %r8
testw %r14w, %r14w
js 0x3478
jmp 0x34cf
movb $0x1, 0x5c(%rbx)
movq %r12, %rdi
movq 0x28(%rsp), %rdx
callq 0x37cf
testb %al, %al
je 0x3532
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7cb9(%rip), %rdi      # 0xafb8
leaq 0x42bc(%rip), %rsi      # 0x75c2
callq 0x21d0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
jmp 0x3461
movb $0x1, 0x160(%rbx)
movq %r12, %rdi
movq 0x30(%rsp), %rdx
callq 0x37cf
testb %al, %al
je 0x3545
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
je 0x3478
movq 0x7c68(%rip), %rdi      # 0xafb8
leaq 0x4290(%rip), %rsi      # 0x75e7
callq 0x21d0
movq %rax, %rdi
movq 0x30(%rsp), %rsi
jmp 0x3461
movb $0x1, 0x394(%rbx)
movq %r12, %rdi
movq 0x90(%rsp), %rdx
callq 0x36ac
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %r8
testb %al, %al
jne 0x3478
jmp 0x35d3
movb $0x1, 0x279(%rbx)
cmpw $0x106, %cx             # imm = 0x106
jae 0x35e6
movzwl 0x4(%r15), %eax
rolw $0x8, %ax
movw %ax, 0x27a(%rbx)
movb 0x6(%r15), %al
movb %al, 0x27c(%rbx)
movb 0x7(%r15), %al
addq $0x8, %r15
movb %al, 0x27d(%rbx)
leal -0x4(%rsi), %eax
movw %ax, 0x37e(%rbx)
movzwl %ax, %edx
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x2170
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %r8
movzwl 0x37e(%rbx), %eax
movb $0x0, 0x27e(%rbx,%rax)
cmpb $0x0, 0x4(%rsp)
je 0x3478
movq 0x7ba6(%rip), %rdi      # 0xafb8
leaq 0x4215(%rip), %rsi      # 0x762e
callq 0x21d0
movzbl 0x27c(%rbx), %esi
movq %rax, %rdi
callq 0x22a0
movq %rax, %rdi
leaq 0x404e(%rip), %r14      # 0x7485
movq %r14, %rsi
callq 0x21d0
movzbl 0x27d(%rbx), %esi
movq %rax, %rdi
callq 0x22a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %r8
addl $-0x4, %r8d
addq 0x40(%rsp), %r12
subl %esi, %r8d
movq %r12, %r15
jmp 0x2ecb
movq 0x7b25(%rip), %rdi      # 0xafb8
leaq 0x3fb6(%rip), %rsi      # 0x7450
callq 0x21d0
movzwl 0x2(%rbx), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x3fd1(%rip), %rsi      # 0x7483
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20c0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7ace(%rip), %rdi      # 0xafb8
leaq 0x3f96(%rip), %rsi      # 0x7487
callq 0x21d0
leaq 0x3fbb(%rip), %rsi      # 0x74b8
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movl %r13d, %esi
callq 0x22a0
leaq 0x4531(%rip), %rsi      # 0x7a48
movq %rax, %rdi
jmp 0x2dcf
movq 0x7a92(%rip), %rdi      # 0xafb8
leaq 0x401c(%rip), %rsi      # 0x7549
jmp 0x2dcf
movq 0x7a7f(%rip), %rdi      # 0xafb8
leaq 0x4069(%rip), %rsi      # 0x75a9
jmp 0x2dcf
movq 0x7a6c(%rip), %rdi      # 0xafb8
leaq 0x407b(%rip), %rsi      # 0x75ce
jmp 0x2dcf
movq 0x7a59(%rip), %rbx      # 0xafb8
leaq 0x4c8b(%rip), %rsi      # 0x81f1
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0x2130
leaq 0x4c7d(%rip), %rsi      # 0x81ff
movq %rax, %rdi
callq 0x21d0
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20c0
leaq 0x4c67(%rip), %rsi      # 0x820b
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
leaq 0x3f5f(%rip), %rsi      # 0x751a
jmp 0x367e
movq 0x79f1(%rip), %rdi      # 0xafb8
leaq 0x40ac(%rip), %rsi      # 0x767a
jmp 0x2dcf
movq 0x79de(%rip), %rdi      # 0xafb8
leaq 0x407b(%rip), %rsi      # 0x765c
jmp 0x2dcf
movq 0x79cb(%rip), %rbx      # 0xafb8
leaq 0x4c81(%rip), %rsi      # 0x8275
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
leaq 0x4009(%rip), %rsi      # 0x7614
jmp 0x367e
movq 0x79a4(%rip), %rdi      # 0xafb8
leaq 0x3f5d(%rip), %rsi      # 0x7578
jmp 0x2dcf
movq 0x7991(%rip), %rdi      # 0xafb8
leaq 0x3e9b(%rip), %rsi      # 0x74c9
jmp 0x2dcf
movq 0x797e(%rip), %rdi      # 0xafb8
leaq 0x407d(%rip), %rsi      # 0x76be
jmp 0x2dcf
movq 0x796b(%rip), %rdi      # 0xafb8
leaq 0x4093(%rip), %rsi      # 0x76e7
jmp 0x2dcf
movq 0x7958(%rip), %rbx      # 0xafb8
leaq 0x4bec(%rip), %rsi      # 0x8253
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
leaq 0x3f75(%rip), %rsi      # 0x75f3
movq %rbx, %rdi
jmp 0x2dcf
movq 0x792b(%rip), %rdi      # 0xafb8
leaq 0x3e53(%rip), %rsi      # 0x74e7
jmp 0x2dcf
movq 0x7918(%rip), %rdi      # 0xafb8
leaq 0x3f94(%rip), %rsi      # 0x763b
jmp 0x2dcf