LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10d86
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x10d70
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x18510(%rip), %rsi     # 0x29231
callq 0xd190
cmpl $0x0, %eax
jne 0x10d62
cmpq $0x0, -0x18(%rbp)
je 0x10d55
movq -0x18(%rbp), %rdi
leaq 0x1f168(%rip), %rsi     # 0x2fea5
callq 0xd340
cmpq $0x0, %rax
je 0x10d55
leaq 0x1f155(%rip), %rax     # 0x2fea4
movq %rax, -0x8(%rbp)
jmp 0x10d8e
leaq 0x1f12d(%rip), %rax     # 0x2fe89
movq %rax, -0x8(%rbp)
jmp 0x10d8e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10d8e
jmp 0x10d72
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10d00
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/lookup.c
// Function: fillLookups
void fillLookups(void)
{
  // Iterate over the PGNs and fill the description of company-code fixed values
  int i;

  for (i = 0; i < pgnListSize; i++)
  {
    Field *f = &pgnList[i].fieldList[0];

    if (f->name != NULL && f->unit != NULL && strcmp(f->name, "Manufacturer Code") == 0)
    {
      int id = 0;

      if (sscanf(f->unit, "=%d", &id) > 0)
      {
#ifdef EXPLAIN
        // The callback will enumerate all fields, set globals to indicate which
        // id to filter and where to fill the description.
        l_id    = id;
        l_field = f;
        (lookupMANUFACTURER_CODE)(fillFieldDescription);
#else
        f->description = (lookupMANUFACTURER_CODE) (id);
#endif
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x973e(%rip), %rcx      # 0x24438
cmpq (%rcx), %rax
jae 0x1ada7
movslq -0x4(%rbp), %rcx
leaq 0x215f2(%rip), %rax     # 0x3c300
imulq $0x15f8, %rcx, %rcx     # imm = 0x15F8
addq %rcx, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1ad97
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ad97
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xa3e4(%rip), %rsi      # 0x25127
callq 0xd190
cmpl $0x0, %eax
jne 0x1ad97
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x15d8b(%rip), %rsi     # 0x30aee
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0xd220
cmpl $0x0, %eax
jle 0x1ad95
movslq -0x14(%rbp), %rax
movq %rax, 0x76a2a(%rip)     # 0x917a8
movq -0x10(%rbp), %rax
movq %rax, 0x76a27(%rip)     # 0x917b0
leaq 0x20(%rip), %rdi        # 0x1adb0
callq 0x10eb0
jmp 0x1ad97
jmp 0x1ad99
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1acef
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1ae18
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x706f6(%rip), %rcx     # 0x8b560
leaq 0x7694f(%rip), %rax     # 0x917c0
subq %rax, %rcx
movl $0x2000, %eax           # imm = 0x2000
subq %rcx, %rax
subq $0x1, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1aeb7
movq 0x706d0(%rip), %rdi     # 0x8b560
movslq -0x24(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0xd0b0
movl %eax, %ecx
movq 0x706b6(%rip), %rax     # 0x8b560
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x706a9(%rip)     # 0x8b560
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0d0
movq %rax, -0x18(%rbp)
movq 0x7061c(%rip), %rax     # 0x8b560
addq -0x18(%rbp), %rax
leaq 0x76871(%rip), %rcx     # 0x917c0
subq %rcx, %rax
cmpq $0x2000, %rax           # imm = 0x2000
ja 0x1afb8
leaq 0x7685f(%rip), %rdi     # 0x917c0
addq -0x8(%rbp), %rdi
addq -0x18(%rbp), %rdi
leaq 0x76850(%rip), %rsi     # 0x917c0
addq -0x8(%rbp), %rsi
movq 0x705e5(%rip), %rdx     # 0x8b560
leaq 0x7683e(%rip), %rax     # 0x917c0
subq %rax, %rdx
subq -0x8(%rbp), %rdx
callq 0xd270
leaq 0x7682b(%rip), %rdi     # 0x917c0
addq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xd270
movq -0x18(%rbp), %rax
addq 0x705af(%rip), %rax     # 0x8b560
movq %rax, 0x705a8(%rip)     # 0x8b560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x6e109(%rip), %rax     # 0x89148
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0x76625(%rip), %rax     # 0x91672
testb $0x1, (%rax)
je 0x1b0b6
leaq 0x6e0ef(%rip), %rax     # 0x89148
leaq 0x1b0b8(%rip), %rcx     # 0x36118
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x7b, %esi
callq 0xd0e0
cmpq $0x0, %rax
je 0x1b0b4
leaq 0x76612(%rip), %rdi     # 0x91690
callq 0xd0d0
cmpq $0xe, %rax
jb 0x1b0a1
leaq 0x15aa8(%rip), %rdi     # 0x30b38
movb $0x0, %al
callq 0x1f720
movl $0x2, %edi
callq 0xd2e0
leaq 0x765e8(%rip), %rdi     # 0x91690
leaq 0x15d62(%rip), %rsi     # 0x30e11
callq 0xd2c0
jmp 0x1b0c7
leaq 0x6e08b(%rip), %rax     # 0x89148
leaq 0xdee7(%rip), %rcx      # 0x28fab
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/print.c
// Function: adjustDataLenStart
bool adjustDataLenStart(const uint8_t **data, size_t *dataLen, size_t *startBit)
{
  size_t bytes = *startBit >> 3;

  if (bytes < *dataLen)
  {
    *data += bytes;
    *dataLen -= bytes;
    *startBit = *startBit & 7;
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1b143
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
andq $0x7, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1b147
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b570
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
andq $0x7, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
shrq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rcx
shrq $0x3, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %r8d
movq -0x28(%rbp), %r9
leaq -0x48(%rbp), %rax
movq %rax, (%rsp)
callq 0x1b150
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/print.c
// Function: getFieldOffsetByOrder
static size_t getFieldOffsetByOrder(const Pgn *pgn, size_t order)
{
  uint8_t i;
  size_t  bitOffset = 0;

  for (i = 0; i < order; i++)
  {
    const Field *field = &pgn->fieldList[i];

    if (i + 1 == order)
    {
      return bitOffset;
    }
    bitOffset += field->size;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x1b5de
movq -0x10(%rbp), %rax
addq $0x18, %rax
movzbl -0x19(%rbp), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movzbl -0x19(%rbp), %eax
addl $0x1, %eax
cltq
cmpq -0x18(%rbp), %rax
jne 0x1b5c5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b5e6
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x1b588
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/print.c
// Function: printEmpty
extern void printEmpty(const char *fieldName, int64_t exceptionValue)
{
  if (showJson)
  {
    if (showJsonEmpty)
    {
      mprintf("null");
    }
    else
    {
      g_skip = true;
    }
  }
  else
  {
    switch (exceptionValue)
    {
      case DATAFIELD_UNKNOWN:
        mprintf("Unknown");
        break;
      case DATAFIELD_ERROR:
        mprintf("ERROR");
        break;
      case DATAFIELD_RESERVED1:
        mprintf("RESERVED1");
        break;
      case DATAFIELD_RESERVED2:
        mprintf("RESERVED2");
        break;
      case DATAFIELD_RESERVED3:
        mprintf("RESERVED3");
        break;
      default:
        mprintf("Unhandled value %ld", exceptionValue);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7606b(%rip), %rax     # 0x91672
testb $0x1, (%rax)
je 0x1b634
leaq 0x76060(%rip), %rax     # 0x91673
testb $0x1, (%rax)
je 0x1b628
leaq 0x1571a(%rip), %rdi     # 0x30d39
movb $0x0, %al
callq 0x1ade0
jmp 0x1b62f
movb $0x1, 0x78191(%rip)     # 0x937c0
jmp 0x1b6be
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x1b6aa
movq -0x18(%rbp), %rax
leaq 0x154a3(%rip), %rcx     # 0x30af4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x139e5(%rip), %rdi     # 0x2f046
movb $0x0, %al
callq 0x1ade0
jmp 0x1b6bc
leaq 0xb2f0(%rip), %rdi      # 0x26961
movb $0x0, %al
callq 0x1ade0
jmp 0x1b6bc
leaq 0x1556a(%rip), %rdi     # 0x30beb
movb $0x0, %al
callq 0x1ade0
jmp 0x1b6bc
leaq 0x15564(%rip), %rdi     # 0x30bf5
movb $0x0, %al
callq 0x1ade0
jmp 0x1b6bc
leaq 0x1555e(%rip), %rdi     # 0x30bff
movb $0x0, %al
callq 0x1ade0
jmp 0x1b6bc
movq -0x10(%rbp), %rsi
leaq 0x15554(%rip), %rdi     # 0x30c09
movb $0x0, %al
callq 0x1ade0
jmp 0x1b6be
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintMMSI
extern bool fieldPrintMMSI(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 (!extractNumberNotEmpty(field, fieldName, data, dataLen, startBit, *bits, &value, &maxValue))
  {
    return true;
  }

  if (showJson)
  {
    mprintf("\"%09u\"", (uint32_t) value);
  }
  else
  {
    mprintf("\"%09u\"", (uint32_t) value);
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %rax
movq (%rax), %r9
leaq -0x40(%rbp), %r10
leaq -0x48(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1b770
testb $0x1, %al
jne 0x1b72b
movb $0x1, -0x1(%rbp)
jmp 0x1b765
leaq 0x75f40(%rip), %rax     # 0x91672
testb $0x1, (%rax)
je 0x1b74d
movq -0x40(%rbp), %rax
movl %eax, %esi
leaq 0x154d9(%rip), %rdi     # 0x30c1d
movb $0x0, %al
callq 0x1ade0
jmp 0x1b761
movq -0x40(%rbp), %rax
movl %eax, %esi
leaq 0x154c3(%rip), %rdi     # 0x30c1d
movb $0x0, %al
callq 0x1ade0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1b0e0
testb $0x1, %al
jne 0x1bc4e
movb $0x0, -0x1(%rbp)
jmp 0x1bce0
movq -0x38(%rbp), %rax
cmpq $0x4, (%rax)
jne 0x1bc5f
cmpq $0x0, -0x30(%rbp)
je 0x1bc82
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rcx
leaq 0x15033(%rip), %rdi     # 0x30ca8
movb $0x0, %al
callq 0x1f720
movb $0x0, -0x1(%rbp)
jmp 0x1bce0
cmpq $0x4, -0x28(%rbp)
jae 0x1bc8f
movb $0x0, -0x1(%rbp)
jmp 0x1bce0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x15038(%rip), %rdi     # 0x30ce0
movb $0x1, %al
callq 0x1ade0
leaq 0x759bc(%rip), %rax     # 0x91672
testb $0x1, (%rax)
jne 0x1bcdc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1bcdc
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x1a336(%rip), %rdi     # 0x3600b
movb $0x0, %al
callq 0x1ade0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %r8
leaq -0x40(%rbp), %r9
leaq -0x48(%rbp), %rax
movq %rax, (%rsp)
callq 0x1b150
testb $0x1, %al
jne 0x1c5f2
movb $0x1, -0x1(%rbp)
jmp 0x1c62b
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x1c609
movb $0x1, 0x771bd(%rip)     # 0x937c0
movb $0x1, -0x1(%rbp)
jmp 0x1c62b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x1c640
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %r8
leaq -0x40(%rbp), %r9
leaq -0x48(%rbp), %rax
movq %rax, (%rsp)
callq 0x1b150
testb $0x1, %al
jne 0x1c882
movb $0x1, -0x1(%rbp)
jmp 0x1c8b8
cmpq $0x0, -0x40(%rbp)
jne 0x1c896
movb $0x1, 0x76f30(%rip)     # 0x937c0
movb $0x1, -0x1(%rbp)
jmp 0x1c8b8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x1c640
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1b0e0
testb $0x1, %al
jne 0x1d49b
movb $0x0, -0x1(%rbp)
jmp 0x1d4fe
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq 0x13b02(%rip), %rdi     # 0x30fb0
movb $0x0, %al
callq 0x1f670
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1d4c9
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1d4d1
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
shlq $0x3, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1d510
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/print.c
// Function: fieldPrintStringLZ
extern bool fieldPrintStringLZ(const Field   *field,
                               const char    *fieldName,
                               const uint8_t *data,
                               size_t         dataLen,
                               size_t         startBit,
                               size_t        *bits)
{
  // STRINGLZ format is <len> [ <data> ... ] <zero>
  size_t len;

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

  // Cap to dataLen
  len   = *data++;
  len   = CB_MIN(len, dataLen - 1);
  *bits = BYTES(len + 2);

  return printString(fieldName, data, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1b0e0
testb $0x1, %al
jne 0x1d6eb
movb $0x0, -0x1(%rbp)
jmp 0x1d759
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1d71c
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1d728
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
addq $0x2, %rcx
shlq $0x3, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1d510
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/print.c
// Function: print_ascii_json_escaped
static void print_ascii_json_escaped(const uint8_t *data, int len)
{
  int c;
  int k;

  for (k = 0; k < len; k++)
  {
    c = data[k];
    switch (c)
    {
      case '\b':
        mprintf("%s", "\\b");
        break;

      case '\n':
        mprintf("%s", "\\n");
        break;

      case '\r':
        mprintf("%s", "\\r");
        break;

      case '\t':
        mprintf("%s", "\\t");
        break;

      case '\f':
        mprintf("%s", "\\f");
        break;

      case '"':
        mprintf("%s", "\\\"");
        break;

      case '\\':
        mprintf("%s", "\\\\");
        break;

      case '/':
        mprintf("%s", "\\/");
        break;

      case '\377':
        // 0xff has been seen on recent Simrad VHF systems, and it seems to indicate
        // end-of-field, with noise following. Assume this does not break other systems.
        return;

      default:
        if (c > 0x00)
        {
          mprintf("%c", c);
        }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1dce5
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $-0x1, %eax
je 0x1dcba
jmp 0x1db92
movl -0x18(%rbp), %eax
subl $0x8, %eax
je 0x1dbf9
jmp 0x1db9c
movl -0x18(%rbp), %eax
subl $0x9, %eax
je 0x1dc47
jmp 0x1dbaa
movl -0x18(%rbp), %eax
subl $0xa, %eax
je 0x1dc13
jmp 0x1dbb4
movl -0x18(%rbp), %eax
subl $0xc, %eax
je 0x1dc5e
jmp 0x1dbc2
movl -0x18(%rbp), %eax
subl $0xd, %eax
je 0x1dc2d
jmp 0x1dbcc
movl -0x18(%rbp), %eax
subl $0x22, %eax
je 0x1dc75
jmp 0x1dbda
movl -0x18(%rbp), %eax
subl $0x2f, %eax
je 0x1dca3
jmp 0x1dbe8
movl -0x18(%rbp), %eax
subl $0x5c, %eax
je 0x1dc8c
jmp 0x1dcbc
leaq 0x1840c(%rip), %rdi     # 0x3600c
leaq 0x13632(%rip), %rsi     # 0x31239
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x183f2(%rip), %rdi     # 0x3600c
leaq 0x1361b(%rip), %rsi     # 0x3123c
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x183d8(%rip), %rdi     # 0x3600c
leaq 0x13604(%rip), %rsi     # 0x3123f
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x183be(%rip), %rdi     # 0x3600c
leaq 0x135ed(%rip), %rsi     # 0x31242
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x183a7(%rip), %rdi     # 0x3600c
leaq 0x135d9(%rip), %rsi     # 0x31245
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x18390(%rip), %rdi     # 0x3600c
leaq 0x135c5(%rip), %rsi     # 0x31248
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x18379(%rip), %rdi     # 0x3600c
leaq 0x135b1(%rip), %rsi     # 0x3124b
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
leaq 0x18362(%rip), %rdi     # 0x3600c
leaq 0x1359d(%rip), %rsi     # 0x3124e
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
jmp 0x1dce5
cmpl $0x0, -0x10(%rbp)
jle 0x1dcd3
movl -0x10(%rbp), %esi
leaq 0x131d7(%rip), %rdi     # 0x30ea3
movb $0x0, %al
callq 0x1ade0
jmp 0x1dcd5
jmp 0x1dcd7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1db66
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/fieldtype.c
// Function: getFieldType
extern FieldType *getFieldType(const char *name)
{
  for (size_t i = 0; i < fieldTypeCount; i++)
  {
    if (strcmp(name, fieldTypeList[i].name) == 0)
    {
      return &fieldTypeList[i];
    }
  }
  logError("fieldType '%s' not found\n", name);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0xac, -0x18(%rbp)
jae 0x1dd59
movq -0x10(%rbp), %rdi
leaq 0x6d857(%rip), %rax     # 0x8b570
imulq $0x90, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xd190
cmpl $0x0, %eax
jne 0x1dd49
leaq 0x6d838(%rip), %rax     # 0x8b570
imulq $0x90, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1dd73
jmp 0x1dd4b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1dd04
movq -0x10(%rbp), %rsi
leaq 0x16ae3(%rip), %rdi     # 0x34847
movb $0x0, %al
callq 0x1f720
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/fieldtype.c
// Function: isPhysicalQuantityListed
static bool isPhysicalQuantityListed(const PhysicalQuantity *pq)
{
  for (size_t i = 0; i < ARRAY_SIZE(PhysicalQuantityList); i++)
  {
    if (PhysicalQuantityList[i] == pq)
    {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x1d, -0x18(%rbp)
jae 0x1efc2
movq -0x18(%rbp), %rcx
leaq 0x1cd4e(%rip), %rax     # 0x3bcf0
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x1efb2
movb $0x1, -0x1(%rbp)
jmp 0x1efc6
jmp 0x1efb4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1ef90
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/fieldtype.c
// Function: getMinRange
static double getMinRange(const char *name, uint32_t size, double resolution, bool sign, int32_t offset)
{
  uint32_t highbit = (sign && offset == 0) ? (size - 1) : size;
  int64_t  minValue;
  double   r;

  if (!sign || offset != 0)
  {
    minValue = INT64_C(0) + offset;
    r        = minValue * resolution;
  }
  else
  {
    minValue = (UINT64_C(1) << highbit) - 1;
    r        = minValue * resolution * -1.0;
  }
  logDebug(
      "%s bits=%llu sign=%u minValue=%lld res=%g offset=%d -> rangeMin %g\n", name, highbit, sign, minValue, resolution, offset, r);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1f005
cmpl $0x0, -0x20(%rbp)
jne 0x1f005
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1f00b
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1f01d
cmpl $0x0, -0x20(%rbp)
je 0x1f03b
movslq -0x20(%rbp), %rax
addq $0x0, %rax
movq %rax, -0x30(%rbp)
cvtsi2sdq -0x30(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x1f06c
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
cvtsi2sdq -0x30(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd 0x12235(%rip), %xmm1    # 0x31298
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movl -0x24(%rbp), %edx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x30(%rbp), %r8
movsd -0x18(%rbp), %xmm0
movl -0x20(%rbp), %r9d
movsd -0x38(%rbp), %xmm1
leaq 0x16ac2(%rip), %rdi     # 0x35b56
movb $0x2, %al
callq 0x1f670
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/fieldtype.c
// Function: fillFieldTypeLookupField
extern void fillFieldTypeLookupField(Field *f, const char *lookup, const size_t key, const char *str, const char *ft)
{
  f->ft = getFieldType(ft);
  if (f->ft == NULL)
  {
    logAbort("LookupFieldType %s(%d) contains an invalid fieldtype '%s'\n", lookup, key, ft);
  }
  f->unit       = f->ft->unit;
  f->resolution = f->ft->resolution;
  f->hasSign    = f->ft->hasSign == True;
  if (f->size == 0)
  {
    f->size = f->ft->size;
  }
  f->name = str;
  if (f->unit != NULL)
  {
    fixupUnit(f);
  }

  logDebug("fillFieldTypeLookupField(Field, lookup='%s', key=%zu, str='%s', ft='%s' unit='%s' bits=%u\n",
           lookup,
           key,
           str,
           ft,
           STRNULL(f->unit),
           f->size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1dcf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x1f26b
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x15b4b(%rip), %rdi     # 0x34daf
movb $0x0, %al
callq 0x1f7d0
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movsd 0x58(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
cmpl $0x2, 0x60(%rax)
sete %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x49(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1f2d6
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f2f5
movq -0x8(%rbp), %rdi
callq 0x1dd80
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f32e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x1f33b
leaq 0xa294(%rip), %rax      # 0x295c9
movq %rax, -0x50(%rbp)
jmp 0x1f33b
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %r9
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
leaq 0x15a8d(%rip), %rdi     # 0x34dea
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1f670
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/parse.c
// Function: findOccurrence
static char *findOccurrence(char *msg, char c, int count)
{
  int   i;
  char *p;

  if (*msg == 0 || *msg == '\n')
  {
    return 0;
  }
  for (i = 0, p = msg; p && i < count; i++, p++)
  {
    p = strchr(p, c);
    if (!p)
    {
      return 0;
    }
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x216ed
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x216f7
movq $0x0, -0x8(%rbp)
jmp 0x2176a
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x2171e
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x21727
jmp 0x21762
movq -0x28(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0xd0e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x21749
movq $0x0, -0x8(%rbp)
jmp 0x2176a
jmp 0x2174b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x21706
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/parse.c
// Function: setParsedValues
static int setParsedValues(RawMessage *m, unsigned int prio, unsigned int pgn, unsigned int dst, unsigned int src, unsigned int len)
{
  m->prio = prio;
  m->pgn  = pgn;
  m->dst  = dst;
  m->src  = src;
  m->len  = len;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3c(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x44(%rax)
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x45(%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x46(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/utf.c
// Function: utf16_to_utf8
size_t utf16_to_utf8(utf16_t const *utf16, size_t utf16_len, utf8_t *utf8, size_t utf8_len)
{
  // The next codepoint that will be written in the UTF-8 string
  // or the size of the required buffer if utf8 is NULL
  size_t utf8_index = 0;

  for (size_t utf16_index = 0; utf16_index < utf16_len; utf16_index++)
  {
    codepoint_t codepoint = decode_utf16(utf16, utf16_len, &utf16_index);

    if (utf8 == NULL)
      utf8_index += calculate_utf8_len(codepoint);
    else
      utf8_index += encode_utf8(codepoint, utf8, utf8_len, utf8_index);
  }

  return utf8_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x22dfd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x22e10
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22dd1
movl -0x34(%rbp), %edi
callq 0x22f00
cltq
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x22ded
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x22f50
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x22def
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x22d98
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/utf.c
// Function: decode_utf16
static codepoint_t decode_utf16(utf16_t const *utf16, size_t len, size_t *index)
{
  utf16_t high = utf16[*index];

  // BMP character
  if ((high & GENERIC_SURROGATE_MASK) != GENERIC_SURROGATE_VALUE)
    return high;

  // Unmatched low surrogate, invalid
  if ((high & SURROGATE_MASK) != HIGH_SURROGATE_VALUE)
    return INVALID_CODEPOINT;

  // String ended with an unmatched high surrogate, invalid
  if (*index == len - 1)
    return INVALID_CODEPOINT;

  utf16_t low = utf16[*index + 1];

  // Unmatched high surrogate, invalid
  if ((low & SURROGATE_MASK) != LOW_SURROGATE_VALUE)
    return INVALID_CODEPOINT;

  // Two correctly matched surrogates, increase index to indicate we've consumed
  // two characters
  (*index)++;

  // The high bits of the codepoint are the value bits of the high surrogate
  // The low bits of the codepoint are the value bits of the low surrogate
  codepoint_t result = high & SURROGATE_CODEPOINT_MASK;
  result <<= SURROGATE_CODEPOINT_BITS;
  result |= low & SURROGATE_CODEPOINT_MASK;
  result += SURROGATE_CODEPOINT_OFFSET;

  // And if all else fails, it's valid
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
andl $0xf800, %eax           # imm = 0xF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x22e4f
movzwl -0x22(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x22ef8
movzwl -0x22(%rbp), %eax
andl $0xfc00, %eax           # imm = 0xFC00
cmpl $0xd800, %eax           # imm = 0xD800
je 0x22e6b
movl $0xfffd, -0x4(%rbp)     # imm = 0xFFFD
jmp 0x22ef8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x22e88
movl $0xfffd, -0x4(%rbp)     # imm = 0xFFFD
jmp 0x22ef8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movw 0x2(%rax,%rcx,2), %ax
movw %ax, -0x24(%rbp)
movzwl -0x24(%rbp), %eax
andl $0xfc00, %eax           # imm = 0xFC00
cmpl $0xdc00, %eax           # imm = 0xDC00
je 0x22eb5
movl $0xfffd, -0x4(%rbp)     # imm = 0xFFFD
jmp 0x22ef8
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movzwl -0x22(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
shll $0xa, %eax
movl %eax, -0x28(%rbp)
movzwl -0x24(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/utf.c
// Function: calculate_utf8_len
static int calculate_utf8_len(codepoint_t codepoint)
{
  // An array with the max values would be more elegant, but a bit too heavy
  // for this common function

  if (codepoint <= UTF8_1_MAX)
    return 1;

  if (codepoint <= UTF8_2_MAX)
    return 2;

  if (codepoint <= UTF8_3_MAX)
    return 3;

  return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x7f, -0x8(%rbp)
ja 0x22f16
movl $0x1, -0x4(%rbp)
jmp 0x22f41
cmpl $0x7ff, -0x8(%rbp)      # imm = 0x7FF
ja 0x22f28
movl $0x2, -0x4(%rbp)
jmp 0x22f41
cmpl $0xffff, -0x8(%rbp)     # imm = 0xFFFF
ja 0x22f3a
movl $0x3, -0x4(%rbp)
jmp 0x22f41
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/utf.c
// Function: encode_utf8
static size_t encode_utf8(codepoint_t codepoint, utf8_t *utf8, size_t len, size_t index)
{
  int size = calculate_utf8_len(codepoint);

  // Not enough space left on the string
  if (index + size > len)
    return 0;

  // Write the continuation bytes in reverse order first
  for (int cont_index = size - 1; cont_index > 0; cont_index--)
  {
    utf8_t cont = codepoint & ~UTF8_CONTINUATION_MASK;
    cont |= UTF8_CONTINUATION_VALUE;

    utf8[index + cont_index] = cont;
    codepoint >>= UTF8_CONTINUATION_CODEPOINT_BITS;
  }

  // Write the leading byte
  utf8_pattern pattern = utf8_leading_bytes[size - 1];

  utf8_t lead = codepoint & ~(pattern.mask);
  lead |= pattern.value;

  utf8[index] = lead;

  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x22f00
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0x22f90
movq $0x0, -0x8(%rbp)
jmp 0x23029
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x22fdf
movl -0xc(%rbp), %eax
andl $0xffffff3f, %eax       # imm = 0xFFFFFF3F
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
orl $0x80, %eax
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rsi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0xc(%rbp)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x22f99
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x131a5(%rip), %rax     # 0x36194
movw (%rax,%rcx,2), %ax
movw %ax, -0x33(%rbp)
movl -0xc(%rbp), %eax
movzbl -0x33(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movb %al, -0x34(%rbp)
movzbl -0x32(%rbp), %ecx
movzbl -0x34(%rbp), %eax
orl %ecx, %eax
movb %al, -0x34(%rbp)
movb -0x34(%rbp), %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x2c(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/utf.c
// Function: utf8_to_utf16
size_t utf8_to_utf16(utf8_t const *utf8, size_t utf8_len, utf16_t *utf16, size_t utf16_len)
{
  // The next codepoint that will be written in the UTF-16 string
  // or the size of the required buffer if utf16 is NULL
  size_t utf16_index = 0;

  for (size_t utf8_index = 0; utf8_index < utf8_len; utf8_index++)
  {
    codepoint_t codepoint = decode_utf8(utf8, utf8_len, &utf8_index);

    if (utf16 == NULL)
      utf16_index += calculate_utf16_len(codepoint);
    else
      utf16_index += encode_utf16(codepoint, utf16, utf16_len, utf16_index);
  }

  return utf16_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x230cd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x230e0
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x230a1
movl -0x34(%rbp), %edi
callq 0x23280
cltq
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x230bd
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x232b0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x230bf
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x23068
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/../common/utf.c
// Function: encode_utf16
static size_t encode_utf16(codepoint_t codepoint, utf16_t *utf16, size_t len, size_t index)
{
  // Not enough space on the string
  if (index >= len)
    return 0;

  if (codepoint <= BMP_END)
  {
    utf16[index] = codepoint;
    return 1;
  }

  // Not enough space on the string for two surrogates
  if (index + 1 >= len)
    return 0;

  codepoint -= SURROGATE_CODEPOINT_OFFSET;

  utf16_t low = LOW_SURROGATE_VALUE;
  low |= codepoint & SURROGATE_CODEPOINT_MASK;

  codepoint >>= SURROGATE_CODEPOINT_BITS;

  utf16_t high = HIGH_SURROGATE_VALUE;
  high |= codepoint & SURROGATE_CODEPOINT_MASK;

  utf16[index]     = high;
  utf16[index + 1] = low;

  return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x232da
movq $0x0, -0x8(%rbp)
jmp 0x23389
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
ja 0x23302
movl -0xc(%rbp), %eax
movw %ax, %dx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movq $0x1, -0x8(%rbp)
jmp 0x23389
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0x2331a
movq $0x0, -0x8(%rbp)
jmp 0x23389
movl -0xc(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0xc(%rbp)
movw $0xdc00, -0x2a(%rbp)    # imm = 0xDC00
movl -0xc(%rbp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movzwl -0x2a(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x2a(%rbp)
movl -0xc(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0xc(%rbp)
movw $0xd800, -0x2c(%rbp)    # imm = 0xD800
movl -0xc(%rbp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movzwl -0x2c(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x2c(%rbp)
movw -0x2c(%rbp), %dx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movw -0x2a(%rbp), %dx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movw %dx, 0x2(%rax,%rcx,2)
movq $0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq