LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/pgn.c
// Function: searchForPgn
const Pgn *searchForPgn(int pgn)
{
  size_t start = 0;
  size_t end   = pgnListSize;
  size_t mid;

  while (start <= end)
  {
    mid = (start + end) / 2;
    if (pgn == pgnList[mid].pgn)
    {
      // Return the first one, unless it is the catch-all
      while (mid > 0 && pgn == pgnList[mid - 1].pgn)
      {
        mid--;
      }
      if (pgnList[mid].fallback)
      {
        mid++;
        if (pgn != pgnList[mid].pgn)
        {
          return NULL;
        }
      }
      return &pgnList[mid];
    }
    if (pgn < pgnList[mid].pgn)
    {
      if (mid == 0)
      {
        return NULL;
      }
      end = mid - 1;
    }
    else
    {
      start = mid + 1;
    }
  }
  return NULL;
}

// Assembly:
leaq 0x11f35(%rip), %rax     # 0x1f3c8
movq (%rax), %rsi
xorl %eax, %eax
leaq 0x2ce61(%rip), %rcx     # 0x3a300
xorl %r8d, %r8d
cmpq %rsi, %r8
ja 0xd525
leaq (%rsi,%r8), %r9
movq %r9, %rdx
shrq %rdx
imulq $0x15f8, %rdx, %r10     # imm = 0x15F8
cmpl %edi, 0x8(%rcx,%r10)
je 0xd4d7
jbe 0xd4cf
cmpq $0x2, %r9
jb 0xd525
decq %rdx
movq %rdx, %rsi
jmp 0xd4a2
incq %rdx
movq %rdx, %r8
jmp 0xd4a2
shrq %r9
imulq $0x15f8, %r9, %rax      # imm = 0x15F8
leaq (%rcx,%rax), %rsi
addq $0x1600, %rsi           # imm = 0x1600
movq %rdx, %rax
movq %rsi, %rcx
subq $0x1, %rdx
jb 0xd507
leaq -0x15f8(%rcx), %rsi
cmpl %edi, -0x2bf0(%rcx)
je 0xd4ec
cmpb $0x1, -0x30(%rcx)
jne 0xd514
cmpl %edi, (%rcx)
jne 0xd523
incq %rax
imulq $0x15f8, %rax, %rax     # imm = 0x15F8
addq 0x2caae(%rip), %rax     # 0x39fd0
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/pgn.c
// Function: searchForUnknownPgn
const Pgn *searchForUnknownPgn(int pgnId)
{
  Pgn *fallback = pgnList;
  Pgn *pgn;

  for (pgn = pgnList; pgn < pgnList + pgnListSize; pgn++)
  {
    if (pgn->fallback)
    {
      fallback = pgn;
    }
    if (pgn->pgn >= pgnId)
    {
      break;
    }
  }
  if (fallback == NULL)
  {
    logAbort("Cannot find catch-all PGN definition for PGN %d; internal definition error\n", pgnId);
  }
  logDebug("Found catch-all PGN %u for PGN %d\n", fallback->pgn, pgnId);
  return fallback;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x11e98(%rip), %rax     # 0x1f3c8
imulq $0x15f8, (%rax), %rax   # imm = 0x15F8
movl %edi, %ebp
leaq 0x2cdc0(%rip), %rbx     # 0x3a300
addq %rbx, %rax
movq %rbx, %rcx
cmpq %rax, %rcx
jae 0xd565
cmpb $0x0, 0x15d0(%rcx)
cmovneq %rcx, %rbx
leaq 0x15f8(%rcx), %rdx
cmpl %ebp, 0x8(%rcx)
movq %rdx, %rcx
jb 0xd546
testq %rbx, %rbx
jne 0xd57a
leaq 0x11a93(%rip), %rdi     # 0x1f004
movl %ebp, %esi
xorl %eax, %eax
callq 0x1be6a
movl 0x8(%rbx), %esi
leaq 0x11acc(%rip), %rdi     # 0x1f050
movl %ebp, %edx
xorl %eax, %eax
callq 0x1bd48
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/pgn.c
// Function: getField
const Field *getField(uint32_t pgnId, uint32_t field)
{
  const Pgn *pgn = searchForPgn(pgnId);

  if (!pgn)
  {
    logDebug("PGN %u is unknown\n", pgnId);
    return 0;
  }
  if (field < pgn->fieldCount)
  {
    return pgn->fieldList + field;
  }
  logDebug("PGN %u does not have field %u\n", pgnId, field);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
callq 0xd48c
testq %rax, %rax
je 0xd8cb
cmpl %ebp, 0x15c0(%rax)
jbe 0xd8e0
movl %ebp, %ecx
imulq $0xa8, %rcx, %rcx
leaq (%rax,%rcx), %r14
addq $0x18, %r14
jmp 0xd8f5
leaq 0x11a7f(%rip), %rdi     # 0x1f351
xorl %r14d, %r14d
movl %ebx, %esi
xorl %eax, %eax
callq 0x1bd48
jmp 0xd8f5
leaq 0x11a7d(%rip), %rdi     # 0x1f364
xorl %r14d, %r14d
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1bd48
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/pgn.c
// Function: camelCase
void camelCase(bool upperCamelCase)
{
  int  i, j;
  bool haveEarlierSpareOrReserved;

  for (i = 0; i < pgnListSize; i++)
  {
    pgnList[i].camelDescription = camelize(pgnList[i].description, upperCamelCase, 0);
    haveEarlierSpareOrReserved  = false;
    for (j = 0; j < ARRAY_SIZE(pgnList[i].fieldList) && pgnList[i].fieldList[j].name; j++)
    {
      const char *name = pgnList[i].fieldList[j].name;

      if (pgnList[i].fieldList[j].camelName == NULL)
      {
        pgnList[i].fieldList[j].camelName = camelize(name, upperCamelCase, haveEarlierSpareOrReserved ? j + 1 : 0);
      }
      else if (upperCamelCase)
      {
        pgnList[i].fieldList[j].camelName
            = camelize(pgnList[i].fieldList[j].camelName, upperCamelCase, haveEarlierSpareOrReserved ? j + 1 : 0);
      }

      if (strcmp(name, "Reserved") == 0 || strcmp(name, "Spare") == 0)
      {
        haveEarlierSpareOrReserved = true;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x2c9ec(%rip), %r14     # 0x3a300
xorl %eax, %eax
movzbl %bl, %ecx
movl %ecx, 0xc(%rsp)
leaq 0x11aa4(%rip), %rcx     # 0x1f3c8
cmpq %rax, (%rcx)
jbe 0xd9fd
movq %rax, 0x10(%rsp)
imulq $0x15f8, %rax, %r15     # imm = 0x15F8
leaq 0x2c9c0(%rip), %r13     # 0x3a300
movq (%r13,%r15), %rdi
xorl %r12d, %r12d
movl 0xc(%rsp), %esi
xorl %edx, %edx
callq 0xda0c
movq %rax, 0x15c8(%r13,%r15)
pushq $0x70
popq %rbp
pushq $0x1
popq %r15
cmpq $0x1618, %rbp           # imm = 0x1618
je 0xd9e9
movq -0x58(%r14,%rbp), %r13
testq %r13, %r13
je 0xd9e9
movq (%r14,%rbp), %rdi
testq %rdi, %rdi
je 0xd994
testb %bl, %bl
je 0xd9b1
testb $0x1, %r12b
movl $0x0, %edx
cmovnel %r15d, %edx
pushq $0x1
popq %rsi
jmp 0xd9a8
testb $0x1, %r12b
movl $0x0, %edx
cmovnel %r15d, %edx
movq %r13, %rdi
movl 0xc(%rsp), %esi
callq 0xda0c
movq %rax, (%r14,%rbp)
movq %r13, %rdi
leaq 0x119c8(%rip), %rsi     # 0x1f383
callq 0xd1a0
testl %eax, %eax
je 0xd9d7
movq %r13, %rdi
leaq 0x119be(%rip), %rsi     # 0x1f38c
callq 0xd1a0
testl %eax, %eax
jne 0xd9da
movb $0x1, %r12b
incl %r15d
addq $0xa8, %rbp
jmp 0xd962
movq 0x10(%rsp), %rax
incq %rax
addq $0x15f8, %r14           # imm = 0x15F8
jmp 0xd91d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/pgn.c
// Function: camelize
static char *camelize(const char *str, bool upperCamelCase, int order)
{
  size_t      len         = strlen(str);
  char       *ptr         = malloc(len + 4);
  char       *p           = ptr;
  const char *s           = str;
  bool        lastIsAlpha = !upperCamelCase;

  if (p == NULL)
  {
    return NULL;
  }

  for (; *s; s++)
  {
    if (isalpha((unsigned char) *s) || isdigit((unsigned char) *s))
    {
      if (lastIsAlpha)
      {
        *p = tolower(*s);
      }
      else
      {
        *p          = toupper(*s);
        lastIsAlpha = true;
      }
      p++;
    }
    else
    {
      lastIsAlpha = false;
    }
  }

  if (order > 0 && (strcmp(str, "Reserved") == 0 || strcmp(str, "Spare") == 0))
  {
    sprintf(p, "%u", order);
  }
  else
  {
    *p = 0;
  }
  return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
callq 0xd0f0
leaq 0x4(%rax), %rdi
callq 0xd200
movq %rax, %r14
testq %rax, %rax
je 0xdae6
movl %ebx, 0xc(%rsp)
xorb $0x1, %bpl
movq %r15, 0x10(%rsp)
movq %r15, %r13
movq %r14, %r12
movzbl (%r13), %ebx
testq %rbx, %rbx
je 0xda99
callq 0xd350
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
testw $0xc00, %ax             # imm = 0xC00
setne %r15b
je 0xda91
testb $0x1, %bpl
je 0xda7b
callq 0xd340
jmp 0xda80
callq 0xd030
movsbq %bl, %rcx
movq (%rax), %rax
movb (%rax,%rcx,4), %al
movb %al, (%r12)
incq %r12
incq %r13
movl %r15d, %ebp
jmp 0xda4e
movl 0xc(%rsp), %ebx
testl %ebx, %ebx
movq 0x10(%rsp), %r15
jle 0xdacc
leaq 0x118d6(%rip), %rsi     # 0x1f383
movq %r15, %rdi
callq 0xd1a0
testl %eax, %eax
je 0xdad3
leaq 0x118cc(%rip), %rsi     # 0x1f38c
movq %r15, %rdi
callq 0xd1a0
testl %eax, %eax
je 0xdad3
movb $0x0, (%r12)
jmp 0xdae6
leaq 0x24039(%rip), %rsi     # 0x31b13
movq %r12, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0xd2c0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: usage
static void usage(char **argv, char **av)
{
  if (av != NULL)
  {
    printf("Unknown or invalid argument %s\n", av[0]);
  }
  printf("Usage: %s -explain | -explain-xml | -explain-ngt-xml | -explain-ik-xml"
         " | [-camel] | [-upper-camel]"
         " | [-version]\n",
         argv[0]);
  printf("     -explain          Export the PGN database in text format\n");
  printf("     -explain-xml      Export the PGN database in XML format\n");
  printf("     -explain-ngt-xml  Export the Actisense PGN database in XML format\n");
  printf("     -explain-ik-xml   Export the iKonvert PGN database in XML format\n");
  printf("     -v1               v1 format: Explain lookups everywhere they are used\n");
  printf("     -camel            Show fieldnames in normalCamelCase\n");
  printf("     -upper-camel      Show fieldnames in UpperCamelCase\n");
  printf("     -version          Print the version of the program and quit\n");
  printf("     -d                Print logging from level ERROR, INFO and DEBUG\n");
  printf("\n");
  exit(1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xdd09
movq (%rsi), %rsi
leaq 0x144eb(%rip), %rdi     # 0x221ed
xorl %eax, %eax
callq 0xd110
movq (%rbx), %rsi
leaq 0x144fa(%rip), %rdi     # 0x2220d
xorl %eax, %eax
callq 0xd110
leaq 0x15415(%rip), %rdi     # 0x23136
callq 0xd0c0
leaq 0x15447(%rip), %rdi     # 0x23174
callq 0xd0c0
leaq 0x15478(%rip), %rdi     # 0x231b1
callq 0xd0c0
leaq 0x154b3(%rip), %rdi     # 0x231f8
callq 0xd0c0
leaq 0x154ed(%rip), %rdi     # 0x2323e
callq 0xd0c0
leaq 0x1552c(%rip), %rdi     # 0x23289
callq 0xd0c0
leaq 0x1555a(%rip), %rdi     # 0x232c3
callq 0xd0c0
leaq 0x15587(%rip), %rdi     # 0x232fc
callq 0xd0c0
leaq 0x155bc(%rip), %rdi     # 0x2333d
callq 0xd0c0
pushq $0xa
popq %rdi
callq 0xd050
pushq $0x1
popq %rdi
callq 0xd2d0
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explain
static void explain(void)
{
  int i;

  printf(COPYRIGHT "\n\nThis program can understand a number of N2K messages. What follows is an explanation of the messages\n"
                   "that it understands. First is a list of completely understood messages, as far as I can tell.\n"
                   "What follows is a list of messages that contain fields that have unknown content or size, or even\n"
                   "completely unknown fields. If you happen to know more, please tell me!\n\n");
  printf("_______ Complete PGNs _________\n\n");
  for (i = 1; i < ARRAY_SIZE(pgnList); i++)
  {
    if (pgnList[i].complete == PACKET_COMPLETE && pgnList[i].pgn < ACTISENSE_BEM)
    {
      explainPGN(pgnList[i]);
    }
  }
  printf("_______ Incomplete PGNs _________\n\n");
  for (i = 1; i < ARRAY_SIZE(pgnList); i++)
  {
    if (pgnList[i].complete != PACKET_COMPLETE && pgnList[i].pgn < ACTISENSE_BEM)
    {
      explainPGN(pgnList[i]);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x15f8, %rsp           # imm = 0x15F8
leaq 0x155dc(%rip), %rdi     # 0x23383
callq 0xd0c0
leaq 0x159fa(%rip), %rdi     # 0x237ad
callq 0xd0c0
pushq $0x37
popq %r14
leaq 0x2db35(%rip), %rbx     # 0x3b8f8
subq $0x1, %r14
jb 0xddf5
cmpw $0x0, 0xc(%rbx)
jne 0xddec
cmpl $0x3ffff, 0x8(%rbx)     # imm = 0x3FFFF
ja 0xddec
movl $0x2bf, %ecx            # imm = 0x2BF
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0xedc8
addq $0x15f8, %rbx           # imm = 0x15F8
jmp 0xddc3
leaq 0x159d2(%rip), %rdi     # 0x237ce
callq 0xd0c0
pushq $0x37
popq %r14
leaq 0x2daec(%rip), %rbx     # 0x3b8f8
subq $0x1, %r14
jb 0xde3e
cmpw $0x0, 0xc(%rbx)
je 0xde35
cmpl $0x3ffff, 0x8(%rbx)     # imm = 0x3FFFF
ja 0xde35
movl $0x2bf, %ecx            # imm = 0x2BF
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0xedc8
addq $0x15f8, %rbx           # imm = 0x15F8
jmp 0xde0c
addq $0x15f8, %rsp           # imm = 0x15F8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: getMinimalPgnLength
static unsigned int getMinimalPgnLength(Pgn *pgn, bool *isVariable)
{
  // Count all fields until the first repeating field
  uint32_t     fieldCount = pgn->fieldCount;
  unsigned int length     = 0;

  *isVariable = false;
  if (pgn->repeatingCount1 > 0)
  {
    fieldCount -= pgn->repeatingCount1 + pgn->repeatingCount2;
    *isVariable = true;
  }

  logDebug("PGN %u fieldCount=%u (was %u)\n", pgn->pgn, fieldCount, pgn->fieldCount);

  for (uint32_t i = 0; i < fieldCount; i++)
  {
    Field *f = &pgn->fieldList[i];

    if (f->size == LEN_VARIABLE)
    {
      *isVariable = true;
    }
    else
    {
      length += f->size;
    }
  }

  if (length % 8 != 0)
  {
    logAbort("PGN %u '%s' has a length of %u bits that does not fill bytes exactly\n", pgn->pgn, pgn->description, length);
  }

  length /= 8; // Bits to bytes

  if (pgn->type == PACKET_SINGLE && length != 8 && pgn->pgn != 59904)
  {
    logAbort("PGN %u '%s' has a length %u bytes but a single-frame PGN should be 8 bytes\n", pgn->pgn, pgn->description, length);
  }

  logDebug("PGN %u len=%u\n", pgn->pgn, length);
  return length;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x15c0(%rdi), %ecx
movb $0x0, (%rsi)
movzbl 0x15eb(%rdi), %eax
movl %ecx, %ebp
testl %eax, %eax
je 0xf2bd
movzbl 0x15ec(%rbx), %edx
addl %edx, %eax
movl %ecx, %ebp
subl %eax, %ebp
movb $0x1, (%r14)
movl 0x8(%rbx), %esi
leaq 0x132d5(%rip), %rdi     # 0x2259c
xorl %r15d, %r15d
movl %ebp, %edx
xorl %eax, %eax
callq 0x1bd48
movl %ebp, %eax
imulq $0xa8, %rax, %rax
xorl %ebp, %ebp
cmpq %r15, %rax
je 0xf2fd
movl 0x28(%rbx,%r15), %ecx
testl %ecx, %ecx
je 0xf2f0
addl %ecx, %ebp
jmp 0xf2f4
movb $0x1, (%r14)
addq $0xa8, %r15
jmp 0xf2de
testb $0x7, %bpl
je 0xf319
movl 0x8(%rbx), %esi
movq (%rbx), %rdx
leaq 0x132ab(%rip), %rdi     # 0x225bb
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1be6a
shrl $0x3, %ebp
cmpl $0x0, 0x10(%rbx)
movl 0x8(%rbx), %esi
jne 0xf34f
cmpl $0x8, %ebp
je 0xf34f
movl $0xea00, %eax           # imm = 0xEA00
cmpl $0xea00, %esi           # imm = 0xEA00
je 0xf351
movq (%rbx), %rdx
leaq 0x132c0(%rip), %rdi     # 0x22601
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1be6a
movl 0x8(%rbx), %eax
jmp 0xf351
movl %esi, %eax
leaq 0x132f5(%rip), %rdi     # 0x2264d
movl %eax, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1bd48
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainFieldtypeXMLv2
static void explainFieldtypeXMLv2(size_t n, const char *s, const char *fts, const LookupInfo *lookup)
{
  FieldType *ft = getFieldType(fts);

  printf("      <EnumFieldType Value='%zu' Name='", n);
  printXML(0, 0, s);
  printf("'");

  if (ft != NULL)
  {
    printf(" FieldType='%s'", getV2Type(ft));
    if (ft->hasSign != Null)
    {
      printf(" Signed='%s'\n", ft->hasSign == True ? "true" : "false");
    }
    if (ft->resolution != 0.0)
    {
      printf(" Resolution='%g'", ft->resolution);
    }
    if (ft->unit != NULL)
    {
      printf(" Unit='%s'", ft->unit);
    }
    if (lookup != NULL && lookup->size != 0)
    {
      printf(" Bits='%zu'", lookup->size);
    }
    else if (ft->size != 0)
    {
      printf(" Bits='%u'", ft->size);
    }
  }
  if (lookup != NULL)
  {
    printf(">\n");
    explainLookupFunction(lookup);
    printf("      </EnumFieldType>\n");
  }
  else
  {
    printf("/>\n");
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x1aef4
movq %rax, %r14
leaq 0x13920(%rip), %rdi     # 0x22daf
movq %r12, %rsi
xorl %eax, %eax
callq 0xd110
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0xf59e
pushq $0x27
popq %rdi
callq 0xd050
testq %r14, %r14
je 0xf565
movq %r14, %rdi
callq 0xf692
leaq 0x137b6(%rip), %rdi     # 0x22c7b
movq %rax, %rsi
xorl %eax, %eax
callq 0xd110
movl 0x60(%r14), %eax
testl %eax, %eax
je 0xf4fa
cmpl $0x2, %eax
leaq 0x14e85(%rip), %rax     # 0x24366
leaq 0x12fb8(%rip), %rsi     # 0x224a0
cmoveq %rax, %rsi
leaq 0x13798(%rip), %rdi     # 0x22c8b
xorl %eax, %eax
callq 0xd110
movsd 0x58(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf50c
jnp 0xf51a
leaq 0x13786(%rip), %rdi     # 0x22c99
movb $0x1, %al
callq 0xd110
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0xf531
leaq 0x13780(%rip), %rdi     # 0x22caa
xorl %eax, %eax
callq 0xd110
testq %rbx, %rbx
je 0xf54f
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0xf54f
leaq 0x1376f(%rip), %rdi     # 0x22cb5
xorl %eax, %eax
callq 0xd110
jmp 0xf56a
movl 0x28(%r14), %esi
testl %esi, %esi
je 0xf565
leaq 0x13763(%rip), %rdi     # 0x22cc1
xorl %eax, %eax
callq 0xd110
testq %rbx, %rbx
je 0xf587
leaq 0x14771(%rip), %rdi     # 0x23ce2
callq 0xd0c0
movq %rbx, %rdi
callq 0xf6ac
leaq 0x14eb6(%rip), %rdi     # 0x2443b
jmp 0xf58e
leaq 0x15010(%rip), %rdi     # 0x2459e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd0c0
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: printXML
static void printXML(int indent, const char *element, const char *p)
{
  int i;

  if (p)
  {
    if (element)
    {
      for (i = 0; i < indent; i++)
      {
        fputs(" ", stdout);
      }
      printf("<%s>", element);
    }
    for (; *p; p++)
    {
      switch (*p)
      {
        case '&':
          fputs("&amp;", stdout);
          break;

        case '<':
          fputs("&lt;", stdout);
          break;

        case '>':
          fputs("&gt;", stdout);
          break;

        case '"':
          fputs("&quot;", stdout);
          break;

        default:
          putchar(*p);
      }
    }
    if (element)
    {
      printf("</%s>\n", element);
    }
  }
}

// Assembly:
testq %rdx, %rdx
je 0xf691
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
testq %rsi, %rsi
je 0xf5f6
xorl %ebx, %ebx
testl %edi, %edi
cmovgl %edi, %ebx
movq 0x2a9fd(%rip), %r12     # 0x39fc8
leaq 0x12e37(%rip), %r15     # 0x22409
subl $0x1, %ebx
jb 0xf5e5
movq (%r12), %rsi
movq %r15, %rdi
callq 0xd170
jmp 0xf5d2
leaq 0x1361f(%rip), %rdi     # 0x22c0b
movq %r13, %rsi
xorl %eax, %eax
callq 0xd110
movq %r13, (%rsp)
movq 0x2a9c7(%rip), %rbx     # 0x39fc8
leaq 0x13618(%rip), %r15     # 0x22c20
leaq 0x13601(%rip), %r12     # 0x22c10
leaq 0x13600(%rip), %r13     # 0x22c16
leaq 0x135fe(%rip), %rbp     # 0x22c1b
movzbl (%r14), %eax
cmpl $0x22, %eax
je 0xf65b
cmpl $0x26, %eax
je 0xf643
cmpl $0x3c, %eax
je 0xf653
cmpl $0x3e, %eax
je 0xf64b
testl %eax, %eax
je 0xf66b
movsbl %al, %edi
callq 0xd050
jmp 0xf666
movq (%rbx), %rsi
movq %r12, %rdi
jmp 0xf661
movq (%rbx), %rsi
movq %rbp, %rdi
jmp 0xf661
movq (%rbx), %rsi
movq %r13, %rdi
jmp 0xf661
movq (%rbx), %rsi
movq %r15, %rdi
callq 0xd170
incq %r14
jmp 0xf61d
movq (%rsp), %rsi
testq %rsi, %rsi
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
je 0xf691
leaq 0x13718(%rip), %rdi     # 0x22da2
xorl %eax, %eax
jmp 0xd110
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainLookupFunction
static void explainLookupFunction(const LookupInfo *lookup)
{
  switch (lookup->type)
  {
    case LOOKUP_TYPE_BIT: {
      if (doV1)
      {
        printf("          <EnumBitValues>\n");
        (lookup->function.bitEnumerator)(explainBitXMLv1);
        printf("          </EnumBitValues>\n");
      }
      else
      {
        printXML(10, "LookupBitEnumeration", lookup->name);
      }
      break;
    }

    case LOOKUP_TYPE_PAIR: {
      if (doV1)
      {
        printf("          <EnumValues>\n");
        (lookup->function.pairEnumerator)(explainPairXMLv1);
        printf("          </EnumValues>\n");
      }
      else
      {
        printXML(10, "LookupEnumeration", lookup->name);
      }
      break;
    }

    case LOOKUP_TYPE_TRIPLET: {
      if (!doV1)
      {
        printXML(10, "LookupIndirectEnumeration", lookup->name);
        printXMLUnsigned(10, "LookupIndirectEnumerationFieldOrder", lookup->val1Order);
      }
      break;
    }

    case LOOKUP_TYPE_FIELDTYPE: {
      if (doV1)
      {
        printf("          <EnumFieldTypeValues>\n");
        (lookup->function.fieldtypeEnumerator)(explainFieldtypeXMLv1);
        printf("          </EnumFieldTypeValues>\n");
      }
      else
      {
        printXML(10, "LookupFieldTypeEnumeration", lookup->name);
      }
      break;
    }

    default:
      break;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xf75e
movq %rdi, %rbx
leaq 0xfcf1(%rip), %rcx      # 0x1f3b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x1, 0x80025(%rip)     # 0x8f6fc
jne 0xf77d
leaq 0x14e54(%rip), %rdi     # 0x24538
callq 0xd0c0
leaq 0xfc(%rip), %rdi        # 0xf7ec
callq *0x10(%rbx)
leaq 0x14e55(%rip), %rdi     # 0x2454f
jmp 0xf74a
cmpb $0x1, 0x7fff9(%rip)     # 0x8f6fc
jne 0xf765
leaq 0x14e5b(%rip), %rdi     # 0x24567
callq 0xd0c0
leaq 0xa6(%rip), %rdi        # 0xf7be
callq *0x10(%rbx)
leaq 0x14e5f(%rip), %rdi     # 0x24581
jmp 0xf74a
cmpb $0x1, 0x7ffd1(%rip)     # 0x8f6fc
jne 0xf771
leaq 0x14dc3(%rip), %rdi     # 0x244f7
callq 0xd0c0
leaq 0x130(%rip), %rdi       # 0xf870
callq *0x10(%rbx)
leaq 0x14dcd(%rip), %rdi     # 0x24517
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd0c0
cmpb $0x0, 0x7ffa0(%rip)     # 0x8f6fc
je 0xf795
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdx
leaq 0x1355d(%rip), %rsi     # 0x22ccc
jmp 0xf787
movq (%rbx), %rdx
leaq 0x135b6(%rip), %rsi     # 0x22d31
jmp 0xf787
movq (%rbx), %rdx
leaq 0x1355a(%rip), %rsi     # 0x22ce1
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf59e
movq (%rbx), %rdx
leaq 0x13554(%rip), %rsi     # 0x22cf3
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0xf59e
movzbl 0x18(%rbx), %edx
leaq 0x13559(%rip), %rsi     # 0x22d0d
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf81a
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: printXMLUnsigned
static void printXMLUnsigned(int indent, const char *element, const unsigned int p)
{
  int i;

  for (i = 0; i < indent; i++)
  {
    fputs(" ", stdout);
  }
  printf("<%s>%u</%s>\n", element, p, element);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
xorl %r15d, %r15d
testl %edi, %edi
cmovgl %edi, %r15d
movq 0x2a791(%rip), %r12     # 0x39fc8
leaq 0x12bcb(%rip), %r14     # 0x22409
subl $0x1, %r15d
jb 0xf852
movq (%r12), %rsi
movq %r14, %rdi
callq 0xd170
jmp 0xf83e
leaq 0x13543(%rip), %rdi     # 0x22d9c
movq %rbx, %rsi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd110
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainFieldtypeXMLv1
static void explainFieldtypeXMLv1(size_t n, const char *s, const char *fts, const LookupInfo *lookup)
{
  FieldType *ft = getFieldType(fts);

  printf("            <EnumFieldType Value='%zu' Name='", n);
  printXML(0, 0, s);
  printf("'");

  if (ft != NULL)
  {
    printf(" FieldType='%s'", getV1Type(ft, NULL));
    if (ft->hasSign != Null)
    {
      printf(" Signed='%s'\n", ft->hasSign == True ? "true" : "false");
    }
    if (ft->resolution != 0.0)
    {
      printf(" Resolution='%g'", ft->resolution);
    }
    if (ft->unit != NULL)
    {
      printf(" Unit='%s'", ft->unit);
    }
    if (lookup != NULL && lookup->size != 0)
    {
      printf(" Bits='%zu'", lookup->size);
    }
    else if (ft->size != 0)
    {
      printf(" Bits='%u'", ft->size);
    }
  }
  printf("/>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x1aef4
movq %rax, %r14
leaq 0x13516(%rip), %rdi     # 0x22da9
movq %r12, %rsi
xorl %eax, %eax
callq 0xd110
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0xf59e
pushq $0x27
popq %rdi
callq 0xd050
testq %r14, %r14
je 0xf96b
movq %r14, %rdi
xorl %esi, %esi
callq 0xf982
leaq 0x133b0(%rip), %rdi     # 0x22c7b
movq %rax, %rsi
xorl %eax, %eax
callq 0xd110
movl 0x60(%r14), %eax
testl %eax, %eax
je 0xf900
cmpl $0x2, %eax
leaq 0x14a7f(%rip), %rax     # 0x24366
leaq 0x12bb2(%rip), %rsi     # 0x224a0
cmoveq %rax, %rsi
leaq 0x13392(%rip), %rdi     # 0x22c8b
xorl %eax, %eax
callq 0xd110
movsd 0x58(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf912
jnp 0xf920
leaq 0x13380(%rip), %rdi     # 0x22c99
movb $0x1, %al
callq 0xd110
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0xf937
leaq 0x1337a(%rip), %rdi     # 0x22caa
xorl %eax, %eax
callq 0xd110
testq %rbx, %rbx
je 0xf955
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0xf955
leaq 0x13369(%rip), %rdi     # 0x22cb5
xorl %eax, %eax
callq 0xd110
jmp 0xf96b
movl 0x28(%r14), %esi
testl %esi, %esi
je 0xf96b
leaq 0x1335d(%rip), %rdi     # 0x22cc1
xorl %eax, %eax
callq 0xd110
leaq 0x14c2c(%rip), %rdi     # 0x2459e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd0c0
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: getV1Type
static const char *getV1Type(const FieldType *ft, const char *fieldName)
{
  for (; ft != NULL; ft = ft->baseFieldTypePtr)
  {
    if (ft->v1Type != NULL)
    {
      if (strcmp(ft->v1Type, "Lat/Lon") == 0)
      {
        if (fieldName != NULL && strstr(fieldName, "ongitude") != NULL)
        {
          return "Longitude";
        }
        return "Latitude";
      }
      return ft->v1Type;
    }
  }
  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xf9a0
movq 0x38(%rdi), %r14
testq %r14, %r14
jne 0xf9a5
movq 0x88(%rdi), %rdi
jmp 0xf989
xorl %r14d, %r14d
jmp 0xf9e1
leaq 0x1342b(%rip), %rsi     # 0x22dd7
movq %r14, %rdi
callq 0xd1a0
testl %eax, %eax
jne 0xf9e1
testq %rbx, %rbx
je 0xf9da
leaq 0x1c024(%rip), %rsi     # 0x2b9e8
movq %rbx, %rdi
callq 0xd330
testq %rax, %rax
je 0xf9da
leaq 0x1c00f(%rip), %r14     # 0x2b9e7
jmp 0xf9e1
leaq 0x1bfeb(%rip), %r14     # 0x2b9cc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: mprintf
extern void mprintf(const char *format, ...)
{
  va_list ap;
  int     remain;

  va_start(ap, format);
  remain = sizeof(mbuf) - (mp - mbuf) - 1;
  if (remain > 0)
  {
    mp += vsnprintf(mp, remain, format, ap);
  }
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x191f2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movq 0x703e7(%rip), %rdi     # 0x89600
leaq 0x76620(%rip), %rax     # 0x8f840
subl %edi, %eax
addl $0x1fff, %eax           # imm = 0x1FFF
testl %eax, %eax
jle 0x19241
movl %eax, %esi
movq %rsp, %rcx
movq %r10, %rdx
callq 0xd0d0
cltq
addq %rax, 0x703bf(%rip)     # 0x89600
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: minsert
extern void minsert(size_t location, const char *str)
{
  size_t len = strlen(str);

  if (mp + len - mbuf <= sizeof(mbuf))
  {
    memmove(mbuf + location + len, mbuf + location, mp - mbuf - location);
    memmove(mbuf + location, str, len);
    mp += len;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0xd0f0
movq %rax, %r14
movq 0x7036a(%rip), %rdx     # 0x89600
leaq (%rdx,%rax), %r13
leaq 0x7659f(%rip), %r15     # 0x8f840
movq %r13, %rax
subq %r15, %rax
cmpq $0x2000, %rax           # imm = 0x2000
ja 0x192d8
addq %r12, %r15
movq %r14, %rdi
addq %r15, %rdi
subq %r15, %rdx
movq %r15, %rsi
callq 0xd270
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xd270
movq %r13, 0x70328(%rip)     # 0x89600
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: getSep
extern char *getSep(void)
{
  char *s = sep;

  if (showJson)
  {
    sep = ",";
    if (strchr(s, '{'))
    {
      if (strlen(closingBraces) >= sizeof(closingBraces) - 2)
      {
        logError("Too many braces\n");
        exit(2);
      }
      strcat(closingBraces, "}");
    }
  }
  else
  {
    sep = ";";
  }

  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6de0c(%rip), %rax     # 0x87148
movq (%rax), %rbx
leaq 0x763ac(%rip), %rcx     # 0x8f6f2
cmpb $0x1, (%rcx)
jne 0x1938b
leaq 0x18978(%rip), %rcx     # 0x31cca
movq %rcx, (%rax)
pushq $0x7b
popq %rsi
movq %rbx, %rdi
callq 0xd100
testq %rax, %rax
je 0x19395
leaq 0x763a4(%rip), %r14     # 0x8f710
movq %r14, %rdi
callq 0xd0f0
cmpq $0xe, %rax
jae 0x193a0
movq %r14, %rdi
callq 0xd0f0
movw $0x7d, (%r14,%rax)
jmp 0x19395
leaq 0x9882(%rip), %rcx      # 0x22c14
movq %rcx, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13339(%rip), %rdi     # 0x2c6e0
xorl %eax, %eax
callq 0x1bdd9
pushq $0x2
popq %rdi
callq 0xd2d0
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: extractNumberByOrder
bool extractNumberByOrder(const Pgn *pgn, size_t order, const uint8_t *data, size_t dataLen, int64_t *value)
{
  const Field *field     = &pgn->fieldList[order - 1];
  size_t       bitOffset = getFieldOffsetByOrder(pgn, order);

  size_t  startBit;
  int64_t maxValue;

  startBit = bitOffset & 7;
  data += bitOffset >> 3;
  dataLen -= bitOffset >> 3;

  return extractNumber(field, data, dataLen, startBit, field->size, value, &maxValue);
}

// Assembly:
movq %r8, %r9
addq $0x18, %rdi
xorl %eax, %eax
xorl %r8d, %r8d
movzbl %al, %eax
cmpq %rsi, %rax
jae 0x195cc
leaq 0x1(%rax), %r10
cmpq %rsi, %r10
je 0x195cf
imulq $0xa8, %rax, %r10
movl 0x10(%rdi,%r10), %r10d
addq %r10, %r8
incl %eax
jmp 0x195a8
xorl %r8d, %r8d
subq $0x18, %rsp
imulq $0xa8, %rsi, %rax
addq %rax, %rdi
addq $-0xa8, %rdi
movl %r8d, %eax
andl $0x7, %eax
shrq $0x3, %r8
addq %r8, %rdx
subq %r8, %rcx
movl 0x10(%rdi), %r8d
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x193d9
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: extractNumberNotEmpty
static bool extractNumberNotEmpty(const Field   *field,
                                  const char    *fieldName,
                                  const uint8_t *data,
                                  size_t         dataLen,
                                  size_t         startBit,
                                  size_t         bits,
                                  int64_t       *value,
                                  int64_t       *maxValue)
{
  int64_t reserved;

  if (!extractNumber(field, data, dataLen, startBit, bits, value, maxValue))
  {
    return false;
  }

  if (*maxValue >= 7)
  {
    reserved = 2; /* DATAFIELD_ERROR and DATAFIELD_UNKNOWN */
  }
  else if (*maxValue > 1)
  {
    reserved = 1; /* DATAFIELD_UNKNOWN */
  }
  else
  {
    reserved = 0;
  }

  if (field->pgn != NULL && field->pgn->repeatingField1 == field->order)
  {
    logDebug("The first repeating fieldset repeats %" PRId64 " times\n", *value);
    g_variableFieldRepeat[0] = *value;
  }

  if (field->pgn != NULL && field->pgn->repeatingField2 == field->order)
  {
    logDebug("The second repeating fieldset repeats %" PRId64 " times\n", *value);
    g_variableFieldRepeat[1] = *value;
  }

  g_previousFieldValue = *value;

  if (*value > *maxValue - reserved)
  {
    printEmpty(fieldName, *value - *maxValue);
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x38(%rsp), %r15
movq 0x30(%rsp), %rbx
movq %r15, (%rsp)
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
movq %rbx, %r9
callq 0x193d9
testb %al, %al
je 0x197a7
movq (%r15), %rax
xorl %ecx, %ecx
cmpq $0x2, %rax
setge %cl
negq %rcx
cmpq $0x7, %rax
pushq $-0x2
popq %r12
cmovlq %rcx, %r12
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x19788
movb 0x15ef(%rax), %cl
cmpb 0x4b(%r14), %cl
jne 0x1975f
movq (%rbx), %rsi
leaq 0x135c2(%rip), %rdi     # 0x2cd03
xorl %eax, %eax
callq 0x1bd48
movl (%rbx), %eax
leaq 0x75fcf(%rip), %rcx     # 0x8f720
movl %eax, (%rcx)
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x19788
movb 0x15f0(%rax), %al
cmpb 0x4b(%r14), %al
jne 0x19788
movq (%rbx), %rsi
leaq 0x135be(%rip), %rdi     # 0x2cd33
xorl %eax, %eax
callq 0x1bd48
movl (%rbx), %eax
leaq 0x75f9b(%rip), %rcx     # 0x8f720
movl %eax, 0x4(%rcx)
movq (%rbx), %rsi
movq %rsi, 0x780b6(%rip)     # 0x91848
movq (%r15), %rcx
addq %rcx, %r12
movb $0x1, %al
cmpq %r12, %rsi
jle 0x197a9
subq %rcx, %rsi
callq 0x19614
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintFloat
extern bool fieldPrintFloat(const Field   *field,
                            const char    *fieldName,
                            const uint8_t *data,
                            size_t         dataLen,
                            size_t         startBit,
                            size_t        *bits)
{
  union
  {
    float    a;
    uint32_t w;
    uint8_t  b[4];
  } f;

  if (!adjustDataLenStart(&data, &dataLen, &startBit))
  {
    return false;
  }

  if (*bits != sizeof(f) || startBit != 0)
  {
    logError("field '%s' FLOAT value unhandled bits=%zu startBit=%zu\n", fieldName, *bits, startBit);
    return false;
  }
  if (dataLen < sizeof(f))
  {
    return false;
  }
#ifdef __BIG_ENDIAN__
  f.b[3] = data[0];
  f.b[2] = data[1];
  f.b[1] = data[2];
  f.b[0] = data[3];
#else
  memcpy(&f.w, data, sizeof(f));
#endif

  mprintf("%g", f.a);
  if (!showJson && field->unit != NULL)
  {
    mprintf(" %s", field->unit);
  }

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %r8, %rdi
shrq $0x3, %rdi
subq %rdi, %rcx
jbe 0x199ba
andl $0x7, %r8d
movq (%r9), %rax
movq %rax, %r9
xorq $0x4, %r9
orq %r8, %r9
je 0x199b4
leaq 0x12ead(%rip), %rdi     # 0x2c850
xorl %ebx, %ebx
movq %rax, %rdx
movq %r8, %rcx
xorl %eax, %eax
callq 0x1bdd9
jmp 0x199bc
cmpq $0x4, %rcx
jae 0x199c6
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cvtss2sd (%rdx,%rdi), %xmm0
leaq 0x12eb6(%rip), %rdi     # 0x2c888
movb $0x1, %bl
movb $0x1, %al
callq 0x19194
leaq 0x75d10(%rip), %rax     # 0x8f6f2
cmpb $0x0, (%rax)
jne 0x199bc
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x199bc
leaq 0x181c6(%rip), %rdi     # 0x31bbd
xorl %eax, %eax
callq 0x19194
jmp 0x199bc
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintDecimal
extern bool fieldPrintDecimal(const Field   *field,
                              const char    *fieldName,
                              const uint8_t *data,
                              size_t         dataLen,
                              size_t         startBit,
                              size_t        *bits)
{
  uint8_t  value = 0;
  uint8_t  bitMask;
  uint64_t bitMagnitude = 1;
  size_t   bit;
  char     buf[128];

  if (!adjustDataLenStart(&data, &dataLen, &startBit))
  {
    return false;
  }

  bitMask = 1 << startBit;

  if (startBit + *bits > dataLen * 8)
  {
    *bits = dataLen * 8 - startBit;
  }

  for (bit = 0; bit < *bits && bit < sizeof(buf) * 8; bit++)
  {
    /* Act on the current bit */
    bool bitIsSet = (*data & bitMask) > 0;
    if (bitIsSet)
    {
      value |= bitMagnitude;
    }

    /* Find the next bit */
    if (bitMask == 128)
    {
      bitMask = 1;
      data++;
    }
    else
    {
      bitMask = bitMask << 1;
    }
    bitMagnitude = bitMagnitude << 1;

    if (bit % 8 == 7)
    {
      if (value < 100)
      {
        mprintf("%02u", value);
      }
      value        = 0;
      bitMagnitude = 1;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %rax
shrq $0x3, %rax
movq %rcx, 0x18(%rsp)
movq %rcx, %rsi
movq %rax, 0x10(%rsp)
subq %rax, %rsi
jbe 0x19af8
andl $0x7, %r8d
pushq $0x1
popq %r9
movl %r9d, %ebp
movl %r8d, %ecx
shll %cl, %ebp
movq 0x8(%rsp), %rax
movq (%rax), %rax
leaq (%rax,%r8), %rcx
shlq $0x3, %rsi
cmpq %rsi, %rcx
jbe 0x19a63
subq %r8, %rsi
movq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsi, %rax
addq 0x10(%rsp), %rdx
movb $0x1, %r13b
xorl %r14d, %r14d
xorl %ecx, %ecx
cmpq $0x3ff, %r14            # imm = 0x3FF
ja 0x19af8
cmpq %rax, %r14
jae 0x19af8
movzbl (%rdx), %edi
movzbl %bpl, %esi
andl %ebp, %edi
movzbl %r13b, %ebx
cmovel %edi, %ebx
orb %cl, %bl
leal (%rsi,%rsi), %ebp
xorl %r12d, %r12d
cmpl $0x80, %esi
cmovel %r9d, %ebp
sete %r15b
movl %r14d, %ecx
notl %ecx
testb $0x7, %cl
jne 0x19ae1
movb $0x1, %r13b
cmpb $0x63, %bl
ja 0x19ae6
movzbl %bl, %esi
xorl %ebx, %ebx
movq %rdx, 0x20(%rsp)
leaq 0x13053(%rip), %rdi     # 0x2cb1a
xorl %eax, %eax
callq 0x19194
pushq $0x1
popq %r9
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
jmp 0x19ae8
addb %r13b, %r13b
jmp 0x19ae8
xorl %ebx, %ebx
movb %r15b, %r12b
addq %r12, %rdx
incq %r14
movl %ebx, %ecx
jmp 0x19a70
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
seta %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintPGN
extern bool fieldPrintPGN(const Field   *field,
                          const char    *fieldName,
                          const uint8_t *data,
                          size_t         dataLen,
                          size_t         startBit,
                          size_t        *bits)
{
  const char *s   = NULL;
  const Pgn  *pgn = NULL;

  int64_t value;
  int64_t maxValue;

  if (!extractNumberNotEmpty(field, fieldName, data, dataLen, startBit, *bits, &value, &maxValue))
  {
    return true;
  }

  if (!IS_MANUFACTURER_PGN(value))
  {
    pgn = searchForPgn(value);
    if (pgn != NULL)
    {
      s = pgn->description;
    }
  }

  if (value >= maxValue - 2)
  {
    printEmpty(fieldName, value - maxValue);
  }
  else if (s != NULL)
  {
    if (showJsonValue)
    {
      mprintf("%" PRId64 ",\"name\":\"%s\"}", value, s);
    }
    else if (showJson)
    {
      mprintf("%" PRId64, value);
    }
    else
    {
      mprintf("%" PRId64 " (%s)", value, s);
    }
  }
  else
  {
    if (showJsonValue)
    {
      mprintf("%" PRId64, value);
      if (showJsonEmpty)
      {
        mprintf(",\"name\":null");
      }
      mprintf("}");
    }
    else
    {
      mprintf("%" PRId64, value);
    }
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq (%r9), %r9
leaq 0x8(%rsp), %rax
leaq 0x10(%rsp), %r10
pushq %rax
pushq %r10
callq 0x196cf
popq %rcx
popq %rdx
testb %al, %al
je 0x1a02f
movq 0x10(%rsp), %rbx
movq %rbx, %rax
andq $-0x100, %rax
cmpq $0xff00, %rax           # imm = 0xFF00
sete %al
cmpq $0x1ef00, %rbx          # imm = 0x1EF00
setge %cl
orb %al, %cl
jne 0x19f85
movl %ebx, %edi
callq 0xd48c
testq %rax, %rax
je 0x19f85
movq (%rax), %rdx
jmp 0x19f87
xorl %edx, %edx
movq 0x8(%rsp), %rax
leaq -0x2(%rax), %rcx
cmpq %rcx, %rbx
jge 0x19fb2
leaq 0x75758(%rip), %rax     # 0x8f6f4
movb (%rax), %bpl
testq %rdx, %rdx
je 0x19fbf
testb %bpl, %bpl
je 0x19fff
leaq 0x129fa(%rip), %rdi     # 0x2c9aa
jmp 0x1a025
subq %rax, %rbx
movq %rbx, %rsi
callq 0x19614
jmp 0x1a02f
leaq 0x127fb(%rip), %rdi     # 0x2c7c1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x19194
testb %bpl, %bpl
je 0x1a02f
leaq 0x75717(%rip), %rax     # 0x8f6f3
cmpb $0x1, (%rax)
jne 0x19fef
leaq 0x128f1(%rip), %rdi     # 0x2c8d9
xorl %eax, %eax
callq 0x19194
leaq 0x129c3(%rip), %rdi     # 0x2c9b9
xorl %eax, %eax
callq 0x19194
jmp 0x1a02f
leaq 0x756ec(%rip), %rax     # 0x8f6f2
cmpb $0x1, (%rax)
jne 0x1a01e
leaq 0x127af(%rip), %rdi     # 0x2c7c1
movq %rbx, %rsi
xorl %eax, %eax
callq 0x19194
jmp 0x1a02f
leaq 0x12923(%rip), %rdi     # 0x2c948
movq %rbx, %rsi
xorl %eax, %eax
callq 0x19194
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintReserved
extern bool fieldPrintReserved(const Field   *field,
                               const char    *fieldName,
                               const uint8_t *data,
                               size_t         dataLen,
                               size_t         startBit,
                               size_t        *bits)
{
  int64_t value;
  int64_t maxValue;

  if (!extractNumber(field, data, dataLen, startBit, *bits, &value, &maxValue))
  {
    return true;
  }
  if (value == maxValue)
  {
    g_skip = true;
    return true;
  }

  return fieldPrintBinary(field, fieldName, data, dataLen, startBit, bits);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq (%r9), %r8
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %r9
movq %rdx, %rsi
movq %rcx, %rdx
movq %r14, %rcx
callq 0x193d9
testb %al, %al
je 0x1a08a
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1a09a
movb $0x1, 0x777b6(%rip)     # 0x91840
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1a0bb
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintSpare
extern bool fieldPrintSpare(const Field   *field,
                            const char    *fieldName,
                            const uint8_t *data,
                            size_t         dataLen,
                            size_t         startBit,
                            size_t        *bits)
{
  int64_t value;
  int64_t maxValue;

  if (!extractNumber(field, data, dataLen, startBit, *bits, &value, &maxValue))
  {
    return true;
  }
  if (value == 0)
  {
    g_skip = true;
    return true;
  }

  return fieldPrintBinary(field, fieldName, data, dataLen, startBit, bits);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq (%r9), %r8
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r9
movq %rdx, %rsi
movq %rcx, %rdx
movq %r14, %rcx
callq 0x193d9
testb %al, %al
je 0x1a2b9
cmpq $0x0, 0x10(%rsp)
je 0x1a2b2
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1a0bb
movb $0x1, 0x77587(%rip)     # 0x91840
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintDate
extern bool fieldPrintDate(const Field   *field,
                           const char    *fieldName,
                           const uint8_t *data,
                           size_t         dataLen,
                           size_t         startBit,
                           size_t        *bits)
{
  char       buf[sizeof("2008.03.10") + 1];
  time_t     t;
  struct tm *tm;
  uint16_t   d;

  if (!adjustDataLenStart(&data, &dataLen, &startBit))
  {
    return false;
  }

  if (startBit != 0)
  {
    return unhandledStartOffset(fieldName, startBit);
  }
  if (*bits != 16)
  {
    return unhandledBitLength(fieldName, *bits);
  }
  if (dataLen < *bits / 8)
  {
    return true;
  }

  d = data[0] + (data[1] << 8);

  if (d >= 0xfffd)
  {
    printEmpty(fieldName, d - INT64_C(0xffff));
    return true;
  }

  t  = d * 86400;
  tm = gmtime(&t);
  if (!tm)
  {
    logAbort("Unable to convert %u to gmtime\n", (unsigned int) t);
  }
  strftime(buf, sizeof(buf), "%Y.%m.%d", tm);
  if (showJson)
  {
    if (showJsonValue)
    {
      mprintf("%" PRIu16 ",\"name\":\"%s\"}", d, buf);
    }
    else
    {
      mprintf("\"%s\"", buf);
    }
  }
  else
  {
    mprintf("%s", buf);
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r8, %rdi
shrq $0x3, %rdi
subq %rdi, %rcx
jbe 0x1a8ef
andq $0x7, %r8
je 0x1a8f3
leaq 0x1247c(%rip), %rdi     # 0x2cd64
xorl %ebx, %ebx
movq %r8, %rdx
jmp 0x1a92b
xorl %ebx, %ebx
jmp 0x1a932
movq (%r9), %rax
cmpq $0x10, %rax
jne 0x1a91f
movb $0x1, %bl
cmpq $0x2, %rcx
jb 0x1a932
movzwl (%rdx,%rdi), %ebp
cmpw $-0x3, %bp
jb 0x1a93d
movzwl %bp, %esi
addq $-0xffff, %rsi          # imm = 0xFFFF0001
callq 0x19614
jmp 0x1a932
leaq 0x12461(%rip), %rdi     # 0x2cd87
xorl %ebx, %ebx
movq %rax, %rdx
xorl %eax, %eax
callq 0x1bdd9
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
imull $0x15180, %ebp, %eax    # imm = 0x15180
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
callq 0xd280
movq %rax, %r14
testq %rax, %rax
jne 0x1a96a
movl 0x18(%rsp), %esi
leaq 0x121bc(%rip), %rdi     # 0x2cb1f
xorl %eax, %eax
callq 0x1be6a
leaq 0x121ce(%rip), %rdx     # 0x2cb3f
leaq 0xc(%rsp), %rdi
pushq $0xc
popq %rsi
movq %r14, %rcx
callq 0xd260
leaq 0x74d6a(%rip), %rax     # 0x8f6f2
cmpb $0x1, (%rax)
jne 0x1a9b0
leaq 0x74d60(%rip), %rax     # 0x8f6f4
cmpb $0x1, (%rax)
jne 0x1a9b9
leaq 0x121a8(%rip), %rdi     # 0x2cb48
leaq 0xc(%rsp), %rdx
movl %ebp, %esi
xorl %eax, %eax
callq 0x19194
jmp 0x1a932
leaq 0x17207(%rip), %rdi     # 0x31bbe
jmp 0x1a9c0
leaq 0x11ffd(%rip), %rdi     # 0x2c9bd
leaq 0xc(%rsp), %rsi
xorl %eax, %eax
callq 0x19194
jmp 0x1a932
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintStringFix
extern bool fieldPrintStringFix(const Field   *field,
                                const char    *fieldName,
                                const uint8_t *data,
                                size_t         dataLen,
                                size_t         startBit,
                                size_t        *bits)
{
  size_t len = field->size / 8;

  if (!adjustDataLenStart(&data, &dataLen, &startBit))
  {
    return false;
  }

  logDebug("fieldPrintStringFix('%s',%zu) size=%zu\n", fieldName, dataLen, len);

  len   = CB_MIN(len, dataLen); // Cap length to remaining bytes in message
  *bits = BYTES(len);
  return printString(fieldName, data, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
shrq $0x3, %rbx
movq %rcx, %rbp
subq %rbx, %rbp
jbe 0x1aa3b
movq %rdx, %r12
movq %rsi, %r13
movl 0x10(%rdi), %r15d
addq %rbx, %r12
shrl $0x3, %r15d
leaq 0x12152(%rip), %rdi     # 0x2cb58
movq %rbp, %rdx
movq %r15, %rcx
xorl %eax, %eax
movq %r9, (%rsp)
callq 0x1bd48
cmpq %r15, %rbp
cmovbq %rbp, %r15
leal (,%r15,8), %eax
movq (%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1aa50
cmpq %rbx, %r14
seta %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq