// File: /workspace/github_cpp_makefile_star2_O3/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 $0x98, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r13
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
je 0x3230
movq 0x9de4(%rip), %r15      # 0xcfb8
leaq 0x6251(%rip), %rsi      # 0x942c
movl $0x17, %edx
movq %r15, %rdi
callq 0x21f0
movl %ebx, %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
leaq 0x7072(%rip), %rsi      # 0xa26e
movl $0x6, %edx
movq %rax, %rdi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x4c8, %edx            # imm = 0x4C8
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
cmpl $0x13, %ebx
ja 0x3264
movq 0x9d6d(%rip), %rbx      # 0xcfb8
leaq 0x61f2(%rip), %rsi      # 0x9444
movl $0xb, %edx
movq %rbx, %rdi
callq 0x21f0
jmp 0x3a0d
movups (%r13), %xmm0
movups %xmm0, (%r14)
movl 0x10(%r13), %eax
movl %eax, 0x10(%r14)
rolw $0x8, (%r14)
movzwl 0x2(%r14), %edx
movl %edx, %ecx
rolw $0x8, %cx
movw %cx, 0x2(%r14)
movzwl %cx, %r15d
leal 0x14(%r15), %ecx
cmpl %ebx, %ecx
jne 0x39be
movb $0x1, %al
testw %dx, %dx
je 0x3a36
addq $0x14, %r13
leaq 0x4bc(%r14), %rax
movq %rax, 0x90(%rsp)
leaq 0x4c0(%r14), %rax
movq %rax, 0x50(%rsp)
leaq 0x3b6(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x3a8(%r14), %rax
movq %rax, 0x88(%rsp)
leaq 0x1c(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x398(%r14), %rax
movq %rax, 0x80(%rsp)
leaq 0x27e(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x265(%r14), %rax
movq %rax, 0x58(%rsp)
leaq 0x162(%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0x5e(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%r14), %rax
movq %rax, 0x78(%rsp)
leaq 0x54(%r14), %rax
movq %rax, 0x48(%rsp)
leaq 0x40(%r14), %rax
movq %rax, 0x70(%rsp)
leaq 0x44(%r14), %rax
movq %rax, 0x40(%rsp)
leaq 0x28(%r14), %rax
movq %rax, 0x68(%rsp)
leaq 0x2c(%r14), %rax
movq %rax, 0x38(%rsp)
leaq 0x18(%r14), %rax
movq %rax, 0x60(%rsp)
movzwl (%r13), %ebx
movzwl 0x2(%r13), %eax
movl %eax, %ecx
rolw $0x8, %cx
rolw $0x8, %bx
movzwl %cx, %r8d
movzwl %bx, %ebp
leal 0x4(%r8), %edx
cmpl %r15d, %edx
ja 0x3a48
leaq 0x4(%r13), %r12
cmpl $0x20, %ebp
movq %r8, 0x30(%rsp)
jg 0x33f5
leal -0x1(%rbp), %edx
cmpl $0xa, %edx
ja 0x395d
leaq 0x6028(%rip), %rsi      # 0x93d4
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movb $0x1, 0x14(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x60(%rsp), %rdx
callq 0x3ce7
testb %al, %al
je 0x3ab4
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x10, %edx
movq 0x9bcf(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x62ab(%rip), %rsi      # 0x969e
jmp 0x3456
cmpl $0x8021, %ebp           # imm = 0x8021
jg 0x3468
cmpl $0x21, %ebp
je 0x365e
cmpl $0x8020, %ebp           # imm = 0x8020
jne 0x395d
movb $0x1, 0x3a4(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x88(%rsp), %rdx
callq 0x3ce7
testb %al, %al
je 0x3ac7
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x13, %edx
movq 0x9b6c(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x6245(%rip), %rsi      # 0x969b
callq 0x21f0
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
jmp 0x3727
cmpl $0x8022, %ebp           # imm = 0x8022
je 0x368c
cmpl $0x8050, %ebp           # imm = 0x8050
jne 0x395d
movb $0x1, 0x4b8(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x90(%rsp), %rdx
callq 0x3ce7
testb %al, %al
je 0x3c4f
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x13, %edx
movq 0x9afe(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x6244(%rip), %rsi      # 0x9708
callq 0x21f0
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
jmp 0x3727
movb $0x1, 0x4c(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x78(%rsp), %rdx
callq 0x3ce7
testb %al, %al
je 0x3c67
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x11, %edx
movq 0x9aae(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x6083(%rip), %rsi      # 0x9597
callq 0x21f0
movq %rbx, %rdi
movq 0x48(%rsp), %rsi
jmp 0x3727
movb $0x1, 0x380(%r14)
cmpw $0x11, %cx
ja 0x3c7f
movl %r8d, %ecx
andl $0x3, %ecx
jne 0x3c7f
movl %r8d, %ecx
shrl $0x2, %ecx
movw %cx, 0x392(%r14)
testw %ax, %ax
je 0x37ff
xorl %eax, %eax
movzwl (%r12,%rax,2), %ecx
rolw $0x8, %cx
movw %cx, 0x382(%r14,%rax,2)
incq %rax
movzwl 0x392(%r14), %ecx
cmpq %rcx, %rax
jb 0x355d
jmp 0x37ff
movb $0x1, 0x34(%r14)
movzwl %ax, %eax
cmpl $0x400, %eax            # imm = 0x400
jne 0x3b93
movl (%r12), %eax
bswapl %eax
movl %eax, 0x38(%r14)
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x10, %edx
movq 0x9a00(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x5f76(%rip), %rsi      # 0x9538
callq 0x21f0
movl 0x38(%r14), %esi
movq %rbx, %rdi
callq 0x2130
movq %rax, %r13
movq (%rax), %rax
jmp 0x3941
movb $0x1, 0x3c(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x70(%rsp), %rdx
callq 0x3ce7
testb %al, %al
je 0x3ca7
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x10, %edx
movq 0x99a6(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x5f4b(%rip), %rsi      # 0x9567
callq 0x21f0
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
jmp 0x3727
movb $0x1, 0x264(%r14)
movzwl %ax, %eax
cmpl $0x1400, %eax           # imm = 0x1400
jne 0x3ada
movl 0x10(%r12), %eax
movq 0x58(%rsp), %rcx
movl %eax, 0x10(%rcx)
movups (%r12), %xmm0
movups %xmm0, (%rcx)
jmp 0x37ff
movb $0x1, 0x3b4(%r14)
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0xe, %edx
movq 0x993b(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x6028(%rip), %rsi      # 0x96af
jmp 0x37d3
movb $0x1, 0x3b5(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x28(%rsp), %rdx
callq 0x3e6c
testb %al, %al
je 0x3a9c
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0xd, %edx
movq 0x98f5(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x600c(%rip), %rsi      # 0x96d9
callq 0x21f0
movq 0x28(%rsp), %r13
jmp 0x37c2
movb $0x1, 0x24(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x68(%rsp), %rdx
callq 0x3ce7
testb %al, %al
je 0x3b7b
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0x12, %edx
movq 0x98a8(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x5ded(%rip), %rsi      # 0x9507
callq 0x21f0
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
callq 0x3dbb
jmp 0x37d8
movb $0x1, 0x5c(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x18(%rsp), %rdx
callq 0x3e6c
testb %al, %al
je 0x3cb7
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0xb, %edx
movq 0x9853(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x5e53(%rip), %rsi      # 0x95c2
callq 0x21f0
movq 0x18(%rsp), %r13
jmp 0x37c2
movb $0x1, 0x160(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x20(%rsp), %rdx
callq 0x3e6c
testb %al, %al
je 0x3c97
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0xb, %edx
movq 0x980a(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x5e2f(%rip), %rsi      # 0x95e7
callq 0x21f0
movq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
addl $-0x4, %r15d
movq 0x30(%rsp), %rcx
movl %ecx, %eax
addq %rax, %r12
movq %r12, %r13
subl %ecx, %r15d
jne 0x3363
jmp 0x3a98
movb $0x1, 0x394(%r14)
movq %r12, %rdi
movl %r8d, %esi
movq 0x80(%rsp), %rdx
callq 0x3ce7
testb %al, %al
jne 0x37ff
jmp 0x3ccf
movb $0x1, 0x279(%r14)
cmpl $0x106, %r8d            # imm = 0x106
jae 0x3b28
movzwl 0x4(%r13), %eax
rolw $0x8, %ax
movw %ax, 0x27a(%r14)
movb 0x6(%r13), %al
movb %al, 0x27c(%r14)
movb 0x7(%r13), %al
addq $0x8, %r13
movb %al, 0x27d(%r14)
leal -0x4(%r8), %eax
movw %ax, 0x37e(%r14)
movzwl %ax, %edx
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2170
movzwl 0x37e(%r14), %eax
movb $0x0, 0x27e(%r14,%rax)
cmpb $0x0, 0x4(%rsp)
je 0x37ff
movl $0xc, %edx
movq 0x96f2(%rip), %rbx      # 0xcfb8
movq %rbx, %rdi
leaq 0x5d5e(%rip), %rsi      # 0x962e
callq 0x21f0
movzbl 0x27c(%r14), %esi
movq %rbx, %rdi
callq 0x2290
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x5b8e(%rip), %rbx      # 0x9485
movq %rbx, %rsi
callq 0x21f0
movzbl 0x27d(%r14), %esi
movq %r13, %rdi
callq 0x2290
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21f0
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x20c0
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r13, %rdi
jmp 0x37f2
cmpb $0x0, 0x4(%rsp)
je 0x39b3
movl $0x13, %edx
movq 0x9648(%rip), %r13      # 0xcfb8
movq %r13, %rdi
leaq 0x5da2(%rip), %rsi      # 0x971c
callq 0x21f0
movq %r13, %rdi
movl %ebp, %esi
callq 0x2290
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
testw %bx, %bx
js 0x37ff
jmp 0x3a34
movl %ebx, %ebx
movq 0x95f1(%rip), %r15      # 0xcfb8
leaq 0x5a82(%rip), %rsi      # 0x9450
movl $0x32, %edx
movq %r15, %rdi
callq 0x21f0
movzwl 0x2(%r14), %esi
movq %r15, %rdi
callq 0x2130
movq %rax, %r14
leaq 0x5a91(%rip), %rsi      # 0x9483
movl $0x3, %edx
movq %rax, %rdi
callq 0x21f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
movq %rax, %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9569(%rip), %rbx      # 0xcfb8
leaq 0x5a31(%rip), %rsi      # 0x9487
movl $0x30, %edx
movq %rbx, %rdi
callq 0x21f0
leaq 0x5a4e(%rip), %rsi      # 0x94b8
movl $0x10, %edx
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2290
movq %rax, %rbx
leaq 0x5fbd(%rip), %rsi      # 0x9a48
movl $0x1, %edx
movq %rax, %rdi
jmp 0x325a
movb $0x1, %al
jmp 0x3a36
movq 0x9515(%rip), %rbx      # 0xcfb8
leaq 0x5c14(%rip), %rsi      # 0x96be
movl $0x1a, %edx
jmp 0x3257
movq 0x94fd(%rip), %rbx      # 0xcfb8
leaq 0x5a07(%rip), %rsi      # 0x94c9
jmp 0x3cdd
movq 0x94ea(%rip), %rbx      # 0xcfb8
leaq 0x5ba5(%rip), %rsi      # 0x967a
jmp 0x3c8d
movq 0x94d7(%rip), %rbx      # 0xcfb8
leaq 0x676b(%rip), %rsi      # 0xa253
movl $0x21, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x5ad0(%rip), %rsi      # 0x95f3
jmp 0x3c8d
movq 0x9489(%rip), %rbx      # 0xcfb8
leaq 0x673f(%rip), %rsi      # 0xa275
movl $0x17, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x5aa3(%rip), %rsi      # 0x9614
movl $0x19, %edx
jmp 0x3257
movq 0x9436(%rip), %rbx      # 0xcfb8
leaq 0x595e(%rip), %rsi      # 0x94e7
movl $0x1f, %edx
jmp 0x3257
movq 0x941e(%rip), %rbx      # 0xcfb8
leaq 0x6650(%rip), %rsi      # 0xa1f1
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21f0
movl 0x30(%rsp), %esi
movq %rbx, %rdi
callq 0x2130
movq %rax, %r14
leaq 0x663b(%rip), %rsi      # 0xa1ff
movl $0xb, %edx
movq %rax, %rdi
callq 0x21f0
movl $0x4, %esi
movq %r14, %rdi
callq 0x2130
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x65fc(%rip), %rsi      # 0xa20b
movl $0x20, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x58d0(%rip), %rsi      # 0x951a
jmp 0x3cdd
leaq 0x5a91(%rip), %rsi      # 0x96e7
movl $0x20, %edx
movq 0x9356(%rip), %rbx      # 0xcfb8
jmp 0x3257
movq 0x934a(%rip), %rbx      # 0xcfb8
leaq 0x5903(%rip), %rsi      # 0x9578
movl $0x1e, %edx
jmp 0x3257
movq 0x9332(%rip), %rbx      # 0xcfb8
leaq 0x59ae(%rip), %rsi      # 0x963b
movl $0x20, %edx
jmp 0x3257
movq 0x931a(%rip), %rbx      # 0xcfb8
leaq 0x5929(%rip), %rsi      # 0x95ce
jmp 0x3cc5
movq 0x930a(%rip), %rbx      # 0xcfb8
leaq 0x5894(%rip), %rsi      # 0x9549
jmp 0x3cdd
movq 0x92fa(%rip), %rbx      # 0xcfb8
leaq 0x58e4(%rip), %rsi      # 0x95a9
movl $0x18, %edx
jmp 0x3257
movq 0x92e2(%rip), %rbx      # 0xcfb8
leaq 0x597f(%rip), %rsi      # 0x965c
movl $0x1d, %edx
jmp 0x3257