// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/fieldtype.c
// Function: fillFieldType
extern void fillFieldType(bool doUnitFixup)
{
  // Percolate fields from physical quantity to fieldtype
  for (size_t i = 0; i < fieldTypeCount; i++)
  {
    FieldType *ft = &fieldTypeList[i];

    if (ft->physical != NULL)
    {
      if (!isPhysicalQuantityListed(ft->physical))
      {
        logAbort("FieldType '%s' contains an unlisted physical quantity '%s'\n", ft->name, ft->physical->name);
      }
      if (ft->unit == NULL)
      {
        ft->unit = ft->physical->abbreviation;
        logDebug("Fieldtype '%s' inherits unit '%s' from physical type '%s'\n", ft->name, STRNULL(ft->unit), ft->physical->name);
      }
      if (ft->url == NULL)
      {
        ft->url = ft->physical->url;
      }
    }
  }

  // Percolate fields from base to derived field
  for (size_t i = 0; i < fieldTypeCount; i++)
  {
    FieldType *ft = &fieldTypeList[i];

    logDebug("filling '%s'\n", ft->name);

    if (ft->baseFieldType != NULL)
    {
      FieldType *base = getFieldType(ft->baseFieldType);

      if (base == NULL)
      {
        logAbort("invalid baseFieldType '%s' found in FieldType '%s'\n", ft->baseFieldType, ft->name);
      }
      if (base > ft)
      {
        logAbort("invalid baseFieldType '%s' must be ordered before FieldType '%s'\n", ft->baseFieldType, ft->name);
      }
      ft->baseFieldTypePtr = base;

      // Inherit parent fields
      if (ft->physical == NULL)
      {
        ft->physical = base->physical;
      }
      if (ft->hasSign == Null && base->hasSign != Null)
      {
        ft->hasSign = base->hasSign;
      }
      if (ft->unit == NULL && base->unit != NULL)
      {
        ft->unit = base->unit;
        logDebug("Fieldtype '%s' inherits unit '%s' from base type '%s'\n", ft->name, ft->unit, base->name);
      }
      if (ft->size == 0 && base->size != 0)
      {
        ft->size = base->size;
        logDebug("Fieldtype '%s' inherits size %u from base type '%s'\n", ft->name, ft->size, base->name);
      }
      if (ft->resolution == 0.0 && base->resolution != 0.0)
      {
        ft->resolution = base->resolution;
        logDebug("Fieldtype '%s' inherits resolution %g from base type '%s'\n", ft->name, ft->resolution, base->name);
      }
      else if (ft->resolution != 0.0 && base->resolution != 0.0 && ft->resolution != base->resolution)
      {
        logAbort("Cannot overrule resolution %g in '%s' with %g in '%s'\n", base->resolution, base->name, ft->resolution, ft->name);
      }
      if (ft->pf == NULL)
      {
        ft->pf = base->pf;
      }
    }

    if (ft->pf == NULL)
    {
      logAbort("FieldType '%s' has no print function\n", ft->name);
    }

    // Set the field range
    if (ft->size != 0 && ft->resolution != 0.0 && ft->hasSign != Null && ft->rangeMax == 0.0)
    {
      ft->rangeMin = getMinRange(ft->name, ft->size, ft->resolution, ft->hasSign == True, ft->offset);
      ft->rangeMax = getMaxRange(ft->name, ft->size, ft->resolution, ft->hasSign == True, ft->offset, NULL);
    }
    else
    {
      ft->rangeMin = nan("");
      ft->rangeMax = nan("");
    }
  }

  for (size_t i = 0; i < pgnListSize; i++)
  {
    uint32_t    pgn   = pgnList[i].pgn;
    const char *pname = pgnList[i].description;
    size_t      j;

    for (j = 0; pgnList[i].fieldList[j].name != NULL; j++)
    {
      Field     *f = &pgnList[i].fieldList[j];
      FieldType *ft;

      if (f->fieldType == NULL)
      {
        logAbort("PGN %u '%s' field '%s' contains NULL fieldType\n", pgn, pname, f->name);
      }
      ft = getFieldType(f->fieldType);
      if (ft == NULL)
      {
        logAbort("PGN %u '%s' field '%s' contains invalid fieldType '%s'\n", pgn, pname, f->name, f->fieldType);
      }
      f->ft = ft;

      if ((ft->hasSign == True && f->hasSign == false) || (ft->hasSign == False && f->hasSign == true))
      {
        logAbort(
            "PGN %u '%s' field '%s' contains different sign attribute than fieldType '%s'\n", pgn, pname, f->name, f->fieldType);
      }

      if (f->resolution == 0.0)
      {
        f->resolution = ft->resolution;
      }
      if (ft->resolution != 0.0 && ft->resolution != f->resolution)
      {
        logAbort("Cannot overrule resolution %g in '%s' with %g in PGN %u field '%s'\n",
                 ft->resolution,
                 ft->name,
                 f->resolution,
                 pgnList[i].pgn,
                 f->name);
      }

      if (ft->size != 0 && f->size == 0)
      {
        f->size = ft->size;
      }
      if (ft->size != 0 && ft->size != f->size)
      {
        logAbort(
            "Cannot overrule size %d in '%s' with %d in PGN %u field '%s'\n", ft->size, ft->name, f->size, pgnList[i].pgn, f->name);
      }

      if (ft->offset != 0 && f->offset == 0)
      {
        f->offset = ft->offset;
      }
      if (ft->offset != f->offset)
      {
        logAbort("Cannot overrule offset %d in '%s' with %d in PGN %u field '%s'\n",
                 ft->offset,
                 ft->name,
                 f->offset,
                 pgnList[i].pgn,
                 f->name);
      }

      if (ft->unit != NULL && f->unit == NULL)
      {
        f->unit = ft->unit;
      }
      if (f->unit != NULL && ft->unit != NULL && strcmp(f->unit, ft->unit) != 0
          && !(strcmp(f->unit, "deg") == 0 && strcmp(ft->unit, "rad") == 0))
      {
        logAbort("PGN %u '%s' field '%s' contains different unit attribute ('%s') than fieldType '%s' ('%s')\n",
                 pgn,
                 pname,
                 f->name,
                 f->unit,
                 f->fieldType,
                 ft->unit);
      }

      if (isnan(f->rangeMax) || f->rangeMax == 0.0)
      {
        f->rangeMin = ft->rangeMin;
        f->rangeMax = ft->rangeMax;
      }
      if (doUnitFixup && f->unit != NULL && f->resolution != 0.0)
      {
        fixupUnit(f);
      }
      if (f->unit != NULL && f->unit[0] == '=') // Is a match field
      {
        pgnList[i].hasMatchFields = true;
      }

      logDebug("%s size=%u res=%g sign=%u rangeMax=%g\n", f->name, f->size, f->resolution, ft->hasSign, f->rangeMax);

      if (f->size != 0 && f->resolution != 0.0 && ft->hasSign != Null && isnan(f->rangeMax))
      {
        f->rangeMin = getMinRange(f->name, f->size, f->resolution, f->hasSign, f->offset);
        f->rangeMax = getMaxRange(f->name, f->size, f->resolution, f->hasSign, f->offset, &f->lookup);
      }

      f->pgn   = &pgnList[i];
      f->order = j + 1;
    }
    if (pgnList[i].type == PACKET_FAST && !ALLOW_PGN_FAST_PACKET(pgn))
    {
      logAbort("PGN %u '%s' is outside fast-packet range\n", pgn, pgnList[i].description);
    }
    if (pgnList[i].type != PACKET_FAST && !ALLOW_PGN_SINGLE_FRAME(pgn))
    {
      logError("PGN %u '%s' is outside single-frame range\n", pgn, pgnList[i].description);
    }
    if (pgnList[i].repeatingCount1 != 0 && pgnList[i].repeatingStart1 == 0)
    {
      logAbort("PGN %u '%s' has no way to determine repeating field set 1\n", pgn, pgnList[i].description);
    }
    if (pgnList[i].repeatingCount2 != 0 && pgnList[i].repeatingStart2 == 0)
    {
      logAbort("PGN %u '%s' has no way to determine repeating field set 2\n", pgn, pgnList[i].description);
    }

    if (pgnList[i].interval == 0)
    {
      pgnList[i].complete |= PACKET_INTERVAL_UNKNOWN;
    }

    if (j == 0 && pgnList[i].complete == PACKET_COMPLETE)
    {
      logError("Internal error: PGN %d '%s' does not have fields.\n", pgnList[i].pgn, pgnList[i].description);
      exit(2);
    }
    pgnList[i].fieldCount = j;
    logDebug("PGN %u '%s' has %u fields\n", pgnList[i].pgn, pname, j);
  }

#ifndef EXPLAIN
  for (size_t i = 0; i < ARRAY_SIZE(fieldtypeEnums); i++)
  {
    uint32_t maxValue = (1 << fieldtypeEnums[i].size) - 1;

    for (size_t j = 0; j < maxValue; j++)
    {
      /* DISCARD */ (fieldtypeEnums[i].function.pair)(j); // Initialize all internal fields on init
    }
  }
#endif

  logDebug("Filled all fieldtypes\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edi, 0x14(%rsp)
leaq 0x6e454(%rip), %r13     # 0x89610
leaq 0x152ad(%rip), %rbx     # 0x30470
leaq 0x152e2(%rip), %r14     # 0x304ac
leaq 0x1eb0f(%rip), %r12     # 0x39ce0
xorl %ebp, %ebp
cmpq $0xac, %rbp
je 0x1b273
imulq $0x90, %rbp, %r15
movq 0x80(%r15,%r13), %rax
testq %rax, %rax
je 0x1b26b
addq %r13, %r15
xorl %ecx, %ecx
cmpq $0xe8, %rcx
je 0x1b211
leaq 0x8(%rcx), %rdx
cmpq %rax, (%rcx,%r12)
movq %rdx, %rcx
jne 0x1b1f9
jmp 0x1b221
movq (%r15), %rsi
movq (%rax), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1be6a
cmpq $0x0, 0x48(%r15)
jne 0x1b255
movq (%r15), %rsi
movq 0x80(%r15), %rax
movq 0x18(%rax), %rdx
movq %rdx, 0x48(%r15)
testq %rdx, %rdx
leaq 0x7ec1(%rip), %rcx      # 0x23105
cmoveq %rcx, %rdx
movq (%rax), %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1bd48
cmpq $0x0, 0x20(%r15)
jne 0x1b26b
movq 0x80(%r15), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%r15)
incq %rbp
jmp 0x1b1d3
leaq 0x1526d(%rip), %r14     # 0x304e7
leaq 0x711d(%rip), %r12      # 0x2239e
xorl %r15d, %r15d
cmpq $0x60c0, %r15           # imm = 0x60C0
je 0x1b4cf
leaq (%r15,%r13), %rbp
movq (%r15,%r13), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1bd48
movq 0x30(%r15,%r13), %rdi
testq %rdi, %rdi
je 0x1b40a
callq 0x1aef4
movq %rax, %rbx
testq %rax, %rax
jne 0x1b2d5
movq (%r15,%r13), %rdx
movq 0x30(%r15,%r13), %rsi
leaq 0x15227(%rip), %rdi     # 0x304f5
xorl %eax, %eax
callq 0x1be6a
cmpq %rbp, %rbx
jbe 0x1b2f1
movq (%r15,%r13), %rdx
movq 0x30(%r15,%r13), %rsi
leaq 0x1523f(%rip), %rdi     # 0x30529
xorl %eax, %eax
callq 0x1be6a
movq %rbx, 0x88(%r15,%r13)
cmpq $0x0, 0x80(%r15,%r13)
jne 0x1b313
movq 0x80(%rbx), %rax
movq %rax, 0x80(%r15,%r13)
cmpl $0x0, 0x60(%r15,%r13)
xorpd %xmm2, %xmm2
jne 0x1b32b
movl 0x60(%rbx), %eax
testl %eax, %eax
je 0x1b32b
movl %eax, 0x60(%r15,%r13)
cmpq $0x0, 0x48(%r15,%r13)
jne 0x1b35a
movq 0x48(%rbx), %rdx
testq %rdx, %rdx
je 0x1b35a
movq %rdx, 0x48(%r15,%r13)
movq (%r15,%r13), %rsi
movq (%rbx), %rcx
leaq 0x1521c(%rip), %rdi     # 0x3056b
xorl %eax, %eax
callq 0x1bd48
xorpd %xmm2, %xmm2
cmpl $0x0, 0x28(%r15,%r13)
jne 0x1b387
movl 0x28(%rbx), %edx
testl %edx, %edx
je 0x1b387
movl %edx, 0x28(%r15,%r13)
movq (%r15,%r13), %rsi
movq (%rbx), %rcx
leaq 0x15226(%rip), %rdi     # 0x305a2
xorl %eax, %eax
callq 0x1bd48
xorpd %xmm2, %xmm2
movsd 0x58(%r15,%r13), %xmm1
ucomisd %xmm2, %xmm1
jne 0x1b3c1
jp 0x1b3c1
movsd 0x58(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jne 0x1b3a3
jnp 0x1b3c1
movsd %xmm0, 0x58(%r15,%r13)
movq (%r15,%r13), %rsi
movq (%rbx), %rdx
leaq 0x1521f(%rip), %rdi     # 0x305d7
movb $0x1, %al
callq 0x1bd48
jmp 0x1b3f3
ucomisd %xmm2, %xmm1
jne 0x1b3c9
jnp 0x1b3f7
movsd 0x58(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jne 0x1b3d6
jnp 0x1b3f7
ucomisd %xmm0, %xmm1
jne 0x1b3de
jnp 0x1b3f7
movq (%rbx), %rsi
movq (%rbp), %rdx
leaq 0x15226(%rip), %rdi     # 0x30612
movb $0x2, %al
callq 0x1be6a
xorpd %xmm2, %xmm2
cmpq $0x0, 0x78(%r15,%r13)
jne 0x1b42e
movq 0x78(%rbx), %rax
movq %rax, 0x78(%r15,%r13)
jmp 0x1b413
movq 0x78(%r15,%r13), %rax
xorpd %xmm2, %xmm2
testq %rax, %rax
jne 0x1b42e
movq (%rbp), %rsi
leaq 0x15226(%rip), %rdi     # 0x30649
xorl %eax, %eax
callq 0x1be6a
xorpd %xmm2, %xmm2
movl 0x28(%r15,%r13), %esi
testl %esi, %esi
je 0x1b4a5
movsd 0x58(%r15,%r13), %xmm0
ucomisd %xmm2, %xmm0
jne 0x1b446
jnp 0x1b4a5
movl 0x60(%r15,%r13), %eax
testl %eax, %eax
je 0x1b4a5
movsd 0x70(%r15,%r13), %xmm1
ucomisd %xmm2, %xmm1
jne 0x1b4a5
jp 0x1b4a5
movq (%r15,%r13), %rdi
xorl %edx, %edx
cmpl $0x2, %eax
sete %dl
movl 0x50(%r15,%r13), %ecx
callq 0x1b92e
movsd %xmm0, 0x68(%r15,%r13)
movq (%r15,%r13), %rdi
movl 0x28(%r15,%r13), %esi
movsd 0x58(%r15,%r13), %xmm0
xorl %edx, %edx
cmpl $0x2, 0x60(%r15,%r13)
sete %dl
movl 0x50(%r15,%r13), %ecx
xorl %r8d, %r8d
callq 0x1b992
jmp 0x1b4bc
movq %r12, %rdi
callq 0xd300
movsd %xmm0, 0x68(%r15,%r13)
movq %r12, %rdi
callq 0xd300
movsd %xmm0, 0x70(%r15,%r13)
addq $0x90, %r15
jmp 0x1b284
leaq 0x1ee2a(%rip), %rax     # 0x3a300
leaq 0x78(%rax), %rbp
xorl %ecx, %ecx
leaq 0x3ee5(%rip), %rax      # 0x1f3c8
cmpq (%rax), %rcx
jae 0x1b8f8
movq %rcx, 0x20(%rsp)
imulq $0x15f8, %rcx, %rax     # imm = 0x15F8
leaq 0x1ee01(%rip), %rcx     # 0x3a300
leaq (%rcx,%rax), %r13
movl 0x8(%rcx,%rax), %r12d
movq (%rcx,%rax), %rax
movq %rax, 0x8(%rsp)
movq %rbp, 0x28(%rsp)
xorl %ebx, %ebx
movq %r12, 0x18(%rsp)
movq -0x60(%rbp), %rcx
testq %rcx, %rcx
je 0x1b7d9
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
jne 0x1b54d
leaq 0x15135(%rip), %rdi     # 0x3066f
movl %r12d, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1be6a
movq -0x58(%rbp), %rdi
callq 0x1aef4
movq %rax, %r15
testq %rax, %rax
jne 0x1b578
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
leaq 0x15136(%rip), %rdi     # 0x3069f
movl %r12d, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1be6a
movq %r15, 0x28(%rbp)
movl 0x60(%r15), %eax
cmpl $0x1, %eax
je 0x1b592
cmpl $0x2, %eax
jne 0x1b5b6
cmpb $0x0, -0x17(%rbp)
jne 0x1b5b6
jmp 0x1b598
cmpb $0x1, -0x17(%rbp)
jne 0x1b5b6
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
leaq 0x15130(%rip), %rdi     # 0x306d7
movl %r12d, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1be6a
movq %rbx, 0x30(%rsp)
movsd -0x30(%rbp), %xmm1
ucomisd 0x3dd8(%rip), %xmm1     # 0x1f3a0
movsd 0x58(%r15), %xmm0
jne 0x1b5db
jp 0x1b5db
movsd %xmm0, -0x30(%rbp)
movapd %xmm0, %xmm1
leaq -0x60(%rbp), %rbx
ucomisd 0x3db9(%rip), %xmm0     # 0x1f3a0
jne 0x1b5eb
jnp 0x1b60b
ucomisd %xmm1, %xmm0
jne 0x1b5f3
jnp 0x1b60b
movq (%r15), %rsi
movl 0x8(%r13), %edx
movq (%rbx), %rcx
leaq 0x15121(%rip), %rdi     # 0x30725
movb $0x2, %al
callq 0x1be6a
movl 0x28(%r15), %esi
testl %esi, %esi
je 0x1b63b
movl -0x50(%rbp), %ecx
testl %ecx, %ecx
je 0x1b638
cmpl %ecx, %esi
je 0x1b63b
movq (%r15), %rdx
movl 0x8(%r13), %r8d
movq (%rbx), %r9
leaq 0x1513a(%rip), %rdi     # 0x30769
xorl %eax, %eax
callq 0x1be6a
jmp 0x1b63b
movl %esi, -0x50(%rbp)
movl 0x50(%r15), %esi
movl -0x38(%rbp), %ecx
testl %esi, %esi
je 0x1b64f
testl %ecx, %ecx
jne 0x1b64f
movl %esi, -0x38(%rbp)
jmp 0x1b66b
cmpl %ecx, %esi
je 0x1b66b
movq (%r15), %rdx
movl 0x8(%r13), %r8d
movq (%rbx), %r9
leaq 0x15143(%rip), %rdi     # 0x307a7
xorl %eax, %eax
callq 0x1be6a
movq 0x48(%r15), %r12
testq %r12, %r12
je 0x1b6e0
movq -0x48(%rbp), %r14
testq %r14, %r14
jne 0x1b684
movq %r12, -0x48(%rbp)
movq %r12, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xd1a0
testl %eax, %eax
je 0x1b6e0
movq %r14, %rdi
leaq 0x12c45(%rip), %rsi     # 0x2e2e2
callq 0xd1a0
testl %eax, %eax
jne 0x1b6b9
movq %r12, %rdi
leaq 0xa8ee(%rip), %rsi      # 0x25f9e
callq 0xd1a0
testl %eax, %eax
je 0x1b6e0
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r9
movq %r12, (%rsp)
leaq 0x1511b(%rip), %rdi     # 0x307e7
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x1be6a
xorpd %xmm0, %xmm0
ucomisd 0x40(%rbp), %xmm0
jne 0x1b6f6
movupd 0x68(%r15), %xmm0
movupd %xmm0, 0x38(%rbp)
cmpb $0x0, 0x14(%rsp)
movq 0x18(%rsp), %r12
je 0x1b724
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x1b73a
movsd -0x30(%rbp), %xmm0
ucomisd 0x3c88(%rip), %xmm0     # 0x1f3a0
jne 0x1b71c
jnp 0x1b72d
movq %rbx, %rdi
callq 0x1af51
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x1b73a
cmpb $0x3d, (%rax)
jne 0x1b73a
movb $0x1, 0x15d1(%r13)
movq -0x60(%rbp), %rsi
movl -0x50(%rbp), %edx
movsd -0x30(%rbp), %xmm0
movl 0x60(%r15), %ecx
movsd 0x40(%rbp), %xmm1
leaq 0x150ed(%rip), %rdi     # 0x30843
movb $0x2, %al
callq 0x1bd48
movl -0x50(%rbp), %esi
testl %esi, %esi
je 0x1b787
movsd -0x30(%rbp), %xmm0
ucomisd 0x3c2f(%rip), %xmm0     # 0x1f3a0
jne 0x1b775
jnp 0x1b787
cmpl $0x0, 0x60(%r15)
je 0x1b787
movsd 0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x1b7a2
movq %r13, 0x30(%rbp)
movq 0x30(%rsp), %rbx
incq %rbx
movb %bl, -0x15(%rbp)
addq $0xa8, %rbp
jmp 0x1b51d
movq -0x60(%rbp), %rdi
movzbl -0x17(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x1b92e
movsd %xmm0, 0x38(%rbp)
movq -0x60(%rbp), %rdi
movl -0x50(%rbp), %esi
movsd -0x30(%rbp), %xmm0
movzbl -0x17(%rbp), %edx
movl -0x38(%rbp), %ecx
movq %rbp, %r8
callq 0x1b992
movsd %xmm0, 0x40(%rbp)
jmp 0x1b787
cmpl $0x1, 0x10(%r13)
jne 0x1b81d
leal -0x10000(%r12), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
setb %al
cmpl $0x40000, %r12d         # imm = 0x40000
setae %cl
orb %al, %cl
jne 0x1b849
movq (%r13), %rdx
leaq 0x15061(%rip), %rdi     # 0x3086a
movl %r12d, %esi
xorl %eax, %eax
callq 0x1be6a
cmpl $0x1, 0x10(%r13)
sete %al
jmp 0x1b81f
xorl %eax, %eax
leal -0x1f000(%r12), %ecx
cmpl $0xffff1000, %ecx       # imm = 0xFFFF1000
setb %cl
orb %al, %cl
jne 0x1b849
movq (%r13), %rdx
leaq 0x15055(%rip), %rdi     # 0x30894
movl %r12d, %esi
xorl %eax, %eax
callq 0x1bdd9
cmpb $0x0, 0x15eb(%r13)
je 0x1b872
cmpb $0x0, 0x15ed(%r13)
jne 0x1b872
movq (%r13), %rdx
leaq 0x15057(%rip), %rdi     # 0x308bf
movl %r12d, %esi
xorl %eax, %eax
callq 0x1be6a
cmpb $0x0, 0x15ec(%r13)
je 0x1b89b
cmpb $0x0, 0x15ee(%r13)
jne 0x1b89b
movq (%r13), %rdx
leaq 0x15069(%rip), %rdi     # 0x308fa
movl %r12d, %esi
xorl %eax, %eax
callq 0x1be6a
cmpw $0x0, 0x15e8(%r13)
jne 0x1b8ab
orb $0x20, 0xc(%r13)
testq %rbx, %rbx
je 0x1b8b6
movl 0x8(%r13), %esi
jmp 0x1b8c2
cmpw $0x0, 0xc(%r13)
movl 0x8(%r13), %esi
je 0x1b914
movl %ebx, 0x15c0(%r13)
leaq 0x15098(%rip), %rdi     # 0x30968
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1bd48
movq 0x20(%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %rbp
addq $0x15f8, %rbp           # imm = 0x15F8
jmp 0x1b4dc
leaq 0x15084(%rip), %rdi     # 0x30983
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1bd48
movq (%r13), %rdx
leaq 0x15016(%rip), %rdi     # 0x30935
xorl %eax, %eax
callq 0x1bdd9
pushq $0x2
popq %rdi
callq 0xd2d0