// File: /workspace/github_c_makefile_star2_O3/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 0x6c49a(%rip), %r13     # 0x88610
leaq 0x1c623(%rip), %r15     # 0x387a0
leaq 0x152ec(%rip), %r14     # 0x31470
leaq 0x1cb55(%rip), %rbp     # 0x38ce0
xorl %r12d, %r12d
leaq (%r12,%r12,8), %rbx
shlq $0x4, %rbx
movq 0x80(%rbx,%r13), %rax
testq %rax, %rax
je 0x1c22e
addq %r13, %rbx
cmpq %r15, %rax
je 0x1c1e0
movq $-0x1, %rcx
cmpq $0x1b, %rcx
je 0x1c1d0
leaq 0x1(%rcx), %rdx
cmpq %rax, 0x10(%rbp,%rcx,8)
movq %rdx, %rcx
jne 0x1c1b6
cmpq $0x1c, %rdx
jb 0x1c1e0
movq (%rbx), %rsi
movq (%rax), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1ce7b
cmpq $0x0, 0x48(%rbx)
jne 0x1c218
movq (%rbx), %rsi
movq 0x80(%rbx), %rax
movq 0x18(%rax), %rdx
movq %rdx, 0x48(%rbx)
testq %rdx, %rdx
leaq 0x7f02(%rip), %rcx      # 0x24105
cmoveq %rcx, %rdx
movq (%rax), %rcx
leaq 0x1529b(%rip), %rdi     # 0x314ac
xorl %eax, %eax
callq 0x1cd55
cmpq $0x0, 0x20(%rbx)
jne 0x1c22e
movq 0x80(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rbx)
incq %r12
cmpq $0xac, %r12
jne 0x1c18e
leaq 0x152a2(%rip), %r14     # 0x314e7
leaq 0x7152(%rip), %r12      # 0x2339e
xorl %r15d, %r15d
leaq (%r15,%r13), %rbp
movq (%r15,%r13), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1cd55
movq 0x30(%r15,%r13), %rdi
testq %rdi, %rdi
je 0x1c3c8
callq 0x1beb8
movq %rax, %rbx
testq %rax, %rax
jne 0x1c293
movq (%r15,%r13), %rdx
movq 0x30(%r15,%r13), %rsi
leaq 0x15269(%rip), %rdi     # 0x314f5
xorl %eax, %eax
callq 0x1ce7b
cmpq %rbp, %rbx
jbe 0x1c2af
movq (%r15,%r13), %rdx
movq 0x30(%r15,%r13), %rsi
leaq 0x15281(%rip), %rdi     # 0x31529
xorl %eax, %eax
callq 0x1ce7b
movq %rbx, 0x88(%r15,%r13)
cmpq $0x0, 0x80(%r15,%r13)
jne 0x1c2d1
movq 0x80(%rbx), %rax
movq %rax, 0x80(%r15,%r13)
cmpl $0x0, 0x60(%r15,%r13)
xorpd %xmm2, %xmm2
jne 0x1c2e9
movl 0x60(%rbx), %eax
testl %eax, %eax
je 0x1c2e9
movl %eax, 0x60(%r15,%r13)
cmpq $0x0, 0x48(%r15,%r13)
jne 0x1c318
movq 0x48(%rbx), %rdx
testq %rdx, %rdx
je 0x1c318
movq %rdx, 0x48(%r15,%r13)
movq (%r15,%r13), %rsi
movq (%rbx), %rcx
leaq 0x1525e(%rip), %rdi     # 0x3156b
xorl %eax, %eax
callq 0x1cd55
xorpd %xmm2, %xmm2
cmpl $0x0, 0x28(%r15,%r13)
jne 0x1c345
movl 0x28(%rbx), %edx
testl %edx, %edx
je 0x1c345
movl %edx, 0x28(%r15,%r13)
movq (%r15,%r13), %rsi
movq (%rbx), %rcx
leaq 0x15268(%rip), %rdi     # 0x315a2
xorl %eax, %eax
callq 0x1cd55
xorpd %xmm2, %xmm2
movsd 0x58(%r15,%r13), %xmm1
ucomisd %xmm2, %xmm1
jne 0x1c37f
jp 0x1c37f
movsd 0x58(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jne 0x1c361
jnp 0x1c37f
movsd %xmm0, 0x58(%r15,%r13)
movq (%r15,%r13), %rsi
movq (%rbx), %rdx
leaq 0x15261(%rip), %rdi     # 0x315d7
movb $0x1, %al
callq 0x1cd55
jmp 0x1c3b1
ucomisd %xmm2, %xmm1
jne 0x1c387
jnp 0x1c3b5
movsd 0x58(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jne 0x1c394
jnp 0x1c3b5
ucomisd %xmm0, %xmm1
jne 0x1c39c
jnp 0x1c3b5
movq (%rbx), %rsi
movq (%rbp), %rdx
leaq 0x15268(%rip), %rdi     # 0x31612
movb $0x2, %al
callq 0x1ce7b
xorpd %xmm2, %xmm2
cmpq $0x0, 0x78(%r15,%r13)
jne 0x1c3ec
movq 0x78(%rbx), %rax
movq %rax, 0x78(%r15,%r13)
jmp 0x1c3d1
movq 0x78(%r15,%r13), %rax
xorpd %xmm2, %xmm2
testq %rax, %rax
jne 0x1c3ec
movq (%rbp), %rsi
leaq 0x15268(%rip), %rdi     # 0x31649
xorl %eax, %eax
callq 0x1ce7b
xorpd %xmm2, %xmm2
movl 0x28(%r15,%r13), %esi
testl %esi, %esi
je 0x1c463
movsd 0x58(%r15,%r13), %xmm0
ucomisd %xmm2, %xmm0
jne 0x1c404
jnp 0x1c463
movl 0x60(%r15,%r13), %eax
testl %eax, %eax
je 0x1c463
movsd 0x70(%r15,%r13), %xmm1
ucomisd %xmm2, %xmm1
jne 0x1c463
jp 0x1c463
movq (%r15,%r13), %rdi
xorl %edx, %edx
cmpl $0x2, %eax
sete %dl
movl 0x50(%r15,%r13), %ecx
callq 0x1c903
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 0x1c96a
jmp 0x1c47a
movq %r12, %rdi
callq 0xd300
movsd %xmm0, 0x68(%r15,%r13)
movq %r12, %rdi
callq 0xd300
movsd %xmm0, 0x70(%r15,%r13)
addq $0x90, %r15
cmpq $0x60c0, %r15           # imm = 0x60C0
jne 0x1c24f
leaq 0x3f2c(%rip), %rax      # 0x203c8
cmpq $0x0, (%rax)
je 0x1c8cc
leaq 0x1ce53(%rip), %rax     # 0x39300
leaq 0x78(%rax), %rbp
xorl %ecx, %ecx
movq %rcx, 0x20(%rsp)
imulq $0x15f8, %rcx, %rax     # imm = 0x15F8
leaq 0x1ce3a(%rip), %rcx     # 0x39300
leaq (%rcx,%rax), %r14
movl 0x8(%rcx,%rax), %ebx
movq (%rcx,%rax), %rdx
movq %rdx, 0x8(%rsp)
movq 0x18(%rcx,%rax), %rcx
testq %rcx, %rcx
movq %rbp, 0x28(%rsp)
je 0x1c7ac
xorl %r13d, %r13d
movq %rbx, 0x18(%rsp)
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
jne 0x1c514
leaq 0x1516d(%rip), %rdi     # 0x3166f
movl %ebx, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1ce7b
movq -0x58(%rbp), %rdi
callq 0x1beb8
movq %rax, %r15
testq %rax, %rax
jne 0x1c53e
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
leaq 0x1516f(%rip), %rdi     # 0x3169f
movl %ebx, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1ce7b
movq %r15, 0x28(%rbp)
movl 0x60(%r15), %eax
cmpl $0x1, %eax
je 0x1c558
cmpl $0x2, %eax
jne 0x1c57b
cmpb $0x0, -0x17(%rbp)
jne 0x1c57b
jmp 0x1c55e
cmpb $0x1, -0x17(%rbp)
jne 0x1c57b
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
leaq 0x1516a(%rip), %rdi     # 0x316d7
movl %ebx, %esi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1ce7b
movsd -0x30(%rbp), %xmm1
ucomisd 0x3e18(%rip), %xmm1     # 0x203a0
movsd 0x58(%r15), %xmm0
jne 0x1c59b
jp 0x1c59b
movsd %xmm0, -0x30(%rbp)
movapd %xmm0, %xmm1
leaq -0x60(%rbp), %rbx
ucomisd 0x3df9(%rip), %xmm0     # 0x203a0
jne 0x1c5ab
jnp 0x1c5cb
ucomisd %xmm1, %xmm0
jne 0x1c5b3
jnp 0x1c5cb
movq (%r15), %rsi
movl 0x8(%r14), %edx
movq (%rbx), %rcx
leaq 0x15161(%rip), %rdi     # 0x31725
movb $0x2, %al
callq 0x1ce7b
movl 0x28(%r15), %esi
testl %esi, %esi
je 0x1c5fb
movl -0x50(%rbp), %ecx
testl %ecx, %ecx
je 0x1c5f8
cmpl %ecx, %esi
je 0x1c5fb
movq (%r15), %rdx
movl 0x8(%r14), %r8d
movq (%rbx), %r9
leaq 0x1517a(%rip), %rdi     # 0x31769
xorl %eax, %eax
callq 0x1ce7b
jmp 0x1c5fb
movl %esi, -0x50(%rbp)
movl 0x50(%r15), %esi
movl -0x38(%rbp), %ecx
testl %esi, %esi
je 0x1c60f
testl %ecx, %ecx
jne 0x1c60f
movl %esi, -0x38(%rbp)
jmp 0x1c62b
cmpl %ecx, %esi
je 0x1c62b
movq (%r15), %rdx
movl 0x8(%r14), %r8d
movq (%rbx), %r9
leaq 0x15183(%rip), %rdi     # 0x317a7
xorl %eax, %eax
callq 0x1ce7b
movq %rbx, 0x30(%rsp)
movq %r14, %rbx
movq 0x48(%r15), %r12
testq %r12, %r12
je 0x1c6a8
movq -0x48(%rbp), %r14
testq %r14, %r14
jne 0x1c64c
movq %r12, -0x48(%rbp)
movq %r12, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xd1a0
testl %eax, %eax
je 0x1c6a8
movq %r14, %rdi
leaq 0x12c7d(%rip), %rsi     # 0x2f2e2
callq 0xd1a0
testl %eax, %eax
jne 0x1c681
movq %r12, %rdi
leaq 0xa926(%rip), %rsi      # 0x26f9e
callq 0xd1a0
testl %eax, %eax
je 0x1c6a8
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r9
movq %r12, (%rsp)
leaq 0x15153(%rip), %rdi     # 0x317e7
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x1ce7b
xorpd %xmm0, %xmm0
ucomisd 0x40(%rbp), %xmm0
jne 0x1c6be
movupd 0x68(%r15), %xmm0
movupd %xmm0, 0x38(%rbp)
cmpb $0x0, 0x14(%rsp)
movq %rbx, %r14
movq 0x18(%rsp), %rbx
je 0x1c6f1
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x1c707
movsd -0x30(%rbp), %xmm0
ucomisd 0x3cbd(%rip), %xmm0     # 0x203a0
jne 0x1c6e7
jnp 0x1c6fa
movq 0x30(%rsp), %rdi
callq 0x1bf0b
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x1c707
cmpb $0x3d, (%rax)
jne 0x1c707
movb $0x1, 0x15d1(%r14)
movq -0x60(%rbp), %rsi
movl -0x50(%rbp), %edx
movsd -0x30(%rbp), %xmm0
movl 0x60(%r15), %ecx
movsd 0x40(%rbp), %xmm1
leaq 0x15120(%rip), %rdi     # 0x31843
movb $0x2, %al
callq 0x1cd55
movl -0x50(%rbp), %esi
testl %esi, %esi
je 0x1c754
movsd -0x30(%rbp), %xmm0
ucomisd 0x3c62(%rip), %xmm0     # 0x203a0
jne 0x1c742
jnp 0x1c754
cmpl $0x0, 0x60(%r15)
je 0x1c754
movsd 0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x1c775
movq %r14, 0x30(%rbp)
incq %r13
movb %r13b, -0x15(%rbp)
movq 0x48(%rbp), %rcx
addq $0xa8, %rbp
testq %rcx, %rcx
jne 0x1c4f2
jmp 0x1c7af
movq -0x60(%rbp), %rdi
movzbl -0x17(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x1c903
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 0x1c96a
movsd %xmm0, 0x40(%rbp)
jmp 0x1c754
xorl %r13d, %r13d
cmpl $0x1, 0x10(%r14)
jne 0x1c7ee
leal -0x10000(%rbx), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
setb %al
cmpl $0x40000, %ebx          # imm = 0x40000
setae %cl
orb %al, %cl
jne 0x1c816
movq (%r14), %rdx
leaq 0x1508f(%rip), %rdi     # 0x3186a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1ce7b
cmpl $0x1, 0x10(%r14)
sete %al
jmp 0x1c7f0
xorl %eax, %eax
leal -0x1f000(%rbx), %ecx
cmpl $0xffff1000, %ecx       # imm = 0xFFFF1000
setb %cl
orb %al, %cl
jne 0x1c816
movq (%r14), %rdx
leaq 0x15087(%rip), %rdi     # 0x31894
movl %ebx, %esi
xorl %eax, %eax
callq 0x1cde8
cmpb $0x0, 0x15eb(%r14)
je 0x1c83d
cmpb $0x0, 0x15ed(%r14)
jne 0x1c83d
movq (%r14), %rdx
leaq 0x1508b(%rip), %rdi     # 0x318bf
movl %ebx, %esi
xorl %eax, %eax
callq 0x1ce7b
cmpb $0x0, 0x15ec(%r14)
je 0x1c864
cmpb $0x0, 0x15ee(%r14)
jne 0x1c864
movq (%r14), %rdx
leaq 0x1509f(%rip), %rdi     # 0x318fa
movl %ebx, %esi
xorl %eax, %eax
callq 0x1ce7b
cmpw $0x0, 0x15e8(%r14)
jne 0x1c874
orb $0x20, 0xc(%r14)
testq %r13, %r13
je 0x1c87f
movl 0x8(%r14), %esi
jmp 0x1c88b
cmpw $0x0, 0xc(%r14)
movl 0x8(%r14), %esi
je 0x1c8e8
movl %r13d, 0x15c0(%r14)
leaq 0x150cf(%rip), %rdi     # 0x31968
movq 0x8(%rsp), %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1cd55
movq 0x20(%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %rbp
addq $0x15f8, %rbp           # imm = 0x15F8
leaq 0x3b05(%rip), %rax      # 0x203c8
cmpq (%rax), %rcx
jb 0x1c4b3
leaq 0x150b0(%rip), %rdi     # 0x31983
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cd55
movq (%r14), %rdx
leaq 0x15043(%rip), %rdi     # 0x31935
xorl %eax, %eax
callq 0x1cde8
movl $0x2, %edi
callq 0xd2d0