LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ke6jjj[P]r-dat/DDSFrameReceiver.cc
// Function: DDSFrameReceiver::NewGroup(unsigned int)
void
DDSFrameReceiver::NewGroup(uint32_t group_id)
{
  //
  // Construct a new group object.
  //
  mBasicGroup = new BasicGroup(group_id);
  
  //
  // Figure out what file name we would have previously stored this
  // group's data under, if available.
  //
  char *groupFilename, *validName, *eccName, *eccValidName;
  groupFilename = validName = eccName = eccValidName = NULL;
  GenerateGroupFilenames(group_id, groupFilename, validName, eccName,
    eccValidName);
  
  //
  // Load any previous data for this group.
  //
  mBasicGroup->LoadFromFile(groupFilename, validName, eccName, eccValidName);
  
  free(groupFilename);
  free(validName);
  free(eccName);
  free(eccValidName);

  //
  // Mark that we now have a group.
  //
  mHaveGroup = true;
  mGroupNumber = group_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x40a4c, %edi          # imm = 0x40A4C
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
callq 0xadd0
jmp 0x7495
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rdi)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x7560
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0xae70
movq -0x28(%rbp), %rdi
callq 0x2140
movq -0x30(%rbp), %rdi
callq 0x2140
movq -0x38(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
callq 0x2140
movq -0x50(%rbp), %rax
movb $0x1, 0x10(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x40a4c, %esi          # imm = 0x40A4C
callq 0x2100
movq -0x18(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/DDSFrameReceiver.cc
// Function: DDSFrameReceiver::GenerateGroupFilenames(unsigned int, char*&, char*&, char*&, char*&)
void
DDSFrameReceiver::GenerateGroupFilenames(uint32_t group_id,
  char*& groupFilename, char*& validName, char*& eccName, char*& eccValidName)
{
  asprintf(&groupFilename, "%s/g%06d.bin", mOutputDirectory, group_id);
  asprintf(&validName,     "%s/g%06d.val", mOutputDirectory, group_id);
  asprintf(&eccName,       "%s/g%06d.ecc.bin", mOutputDirectory, group_id);
  asprintf(&eccValidName,  "%s/g%06d.ecc.val", mOutputDirectory, group_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rdx
movl -0xc(%rbp), %ecx
leaq 0x7d63(%rip), %rsi      # 0xf2fc
movb $0x0, %al
callq 0x2080
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x20(%rax), %rdx
movl -0xc(%rbp), %ecx
leaq 0x7d53(%rip), %rsi      # 0xf309
movb $0x0, %al
callq 0x2080
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x20(%rax), %rdx
movl -0xc(%rbp), %ecx
leaq 0x7d43(%rip), %rsi      # 0xf316
movb $0x0, %al
callq 0x2080
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x20(%rax), %rdx
movl -0xc(%rbp), %ecx
leaq 0x7d37(%rip), %rsi      # 0xf327
movb $0x0, %al
callq 0x2080
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/DDSGroup3.cc
// Function: DDSGroup3::ErrorDescription(DDSGroup3::DecodeError)
const char *
DDSGroup3::ErrorDescription(DDSGroup3::DecodeError r)
{
  switch (r) {
  case DECODE_OK:
    return "DECODE_OK";
  case A_MISSING_SUBCODE_3:
    return "A_MISSING_SUBCODE_3";
  case B_MISSING_SUBCODE_3:
    return "B_MISSING_SUBCODE_3";
  case MISSING_SUBCODE_4:
    return "MISSING_SUBCODE_4";
  case ABSOLUTE_FRAME_MISMATCH:
    return "ABSOLUTE_FRAME_MISMATCH";
  case LOGICAL_FRAME_MISMATCH:
    return "LOGICAL_FRAME_MISMATCH";
  case UNKNOWN_AREA_ID:
    return "UNKNOWN_AREA_ID";
  case C2_ERRORS_PRESENT:
    return "C2_ERRORS_PRESENT";
  case INVALID_HEADER:
    return "INVALID_HEADER";
  case ECC4_ERROR:
    return "ECC4_ERROR";
  case MISSING_SUBCODE_1:
    return "MISSING_SUBCODE_1";
  case MISSING_SUBCODE_2:
    return "MISSING_SUBCODE_2";
  default:
    return "?";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x7f81
movq -0x18(%rbp), %rax
leaq 0x7465(%rip), %rcx      # 0xf338
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7485(%rip), %rax      # 0xf368
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x747f(%rip), %rax      # 0xf372
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x7483(%rip), %rax      # 0xf386
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x7487(%rip), %rax      # 0xf39a
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x748c(%rip), %rax      # 0xf3ac
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x7497(%rip), %rax      # 0xf3c4
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x74a1(%rip), %rax      # 0xf3db
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x74a4(%rip), %rax      # 0xf3eb
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x74a9(%rip), %rax      # 0xf3fd
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x74ab(%rip), %rax      # 0xf40c
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x74a9(%rip), %rax      # 0xf417
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x74ae(%rip), %rax      # 0xf429
movq %rax, -0x8(%rbp)
jmp 0x7f8c
leaq 0x6edc(%rip), %rax      # 0xee64
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/DDSGroup3.cc
// Function: GetSubcodePack(unsigned int, Track const&, Track const&, unsigned char const**)
static bool
GetSubcodePack(unsigned int id, const Track& A, const Track& B,
               const uint8_t ** subcode)
{
  if (!A.GetSubcode(id, subcode)) {
    //
    // A's sub-code is missing. Perhaps we can get it from B.
    //
    if (!B.GetSubcode(id, subcode)) {
      //
      // Nope. Missing from both. We should have it.
      //
      return false;
    }
  }
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4640
testb $0x1, %al
jne 0x7fe7
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4640
testb $0x1, %al
jne 0x7fe5
movb $0x0, -0x1(%rbp)
jmp 0x7feb
jmp 0x7fe7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/ECC_C1.cc
// Function: ECC_C1::ComputeSyndrome(unsigned char (&) [4])
bool
ECC_C1::ComputeSyndrome(uint8_t (&syndrome)[ECC_C1::kTwoT])
{
  //
  // Multiply the filled in vector by the check matrix to produce a
  // result vector.
  //
  bool ok = true;
  for (size_t i = 0; i < kTwoT; i++) {
    uint8_t result = 0;
    for (size_t j = 0; j < kN; j++) {
      result ^= ECC_GF28_multiply(mData[j], gHp[i][j]);
    }

    syndrome[i] = result;

    //
    // Everything is ok if all previous entries are zero and this
    // entry is zero.
    //
    ok = ok && result == 0;
  }

  return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jae 0x8308
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x20, -0x30(%rbp)
jae 0x82c9
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rcx
leaq 0x71a8(%rip), %rax      # 0xf440
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movzbl %dl, %edi
movzbl (%rax,%rcx), %esi
callq 0x9250
movzbl %al, %ecx
movzbl -0x21(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x827b
movb -0x21(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x39(%rbp)
je 0x82ef
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8264
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/./ReedSolomon_EUA.h
// Function: void poly_multiply_by_x<5ul>(unsigned char const (&) [5ul], unsigned char (&) [5ul])
void
poly_multiply_by_x(const uint8_t (&in)[n], uint8_t (&out)[n])
{
  //
  // Perform this in a manner that will be safe even if in and out
  // are the same array.
  //
  for (size_t i = n - 1; i > 0; i--)
    out[i] = in[i-1];
  out[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x4, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x8ba3
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8b74
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/./ReedSolomon_EUA.h
// Function: unsigned char poly_evaluate<4ul>(unsigned char const (&) [4ul], unsigned char)
uint8_t
poly_evaluate(const uint8_t (&in)[n], uint8_t x)
{
  uint8_t y = x;
  uint8_t r = in[0];
  
  for (size_t i = 1; i < n; i++) {
    r ^= ECC_GF28_multiply(in[i], y);
    y = ECC_GF28_multiply(y, x);
  }
  
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0xb(%rbp)
movq $0x1, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x8cd3
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movzbl %al, %edi
movzbl -0xa(%rbp), %esi
callq 0x9250
movzbl %al, %ecx
movzbl -0xb(%rbp), %eax
xorl %ecx, %eax
movb %al, -0xb(%rbp)
movb -0xa(%rbp), %al
movzbl %al, %edi
movzbl -0x9(%rbp), %esi
callq 0x9250
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8c89
movb -0xb(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/ECC_GF28.cc
// Function: ECC_GF28_multiply(unsigned char, unsigned char)
uint8_t
ECC_GF28_multiply(uint8_t a, uint8_t b)
{
  if (a == 0 || b == 0)
    return 0;

  if (a == 1)
    return b;

  if (b == 1)
    return a;
  
  //
  // Use the discrete logarithm table to make multiplicaton an O(1)
  // operation.
  //
  return kPowAlpha[(kLogAlpha[a] + kLogAlpha[b]) % 255];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x0, %eax
je 0x9272
movzbl -0x3(%rbp), %eax
cmpl $0x0, %eax
jne 0x9278
movb $0x0, -0x1(%rbp)
jmp 0x92d6
movzbl -0x2(%rbp), %eax
cmpl $0x1, %eax
jne 0x9289
movb -0x3(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x92d6
movzbl -0x3(%rbp), %eax
cmpl $0x1, %eax
jne 0x929a
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x92d6
movzbl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x6349(%rip), %rax      # 0xf5f0
movzbl (%rax,%rcx), %eax
movzbl -0x3(%rbp), %ecx
movl %ecx, %edx
leaq 0x6338(%rip), %rcx      # 0xf5f0
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xff, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x6220(%rip), %rax      # 0xf4f0
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/ECC_GF28.cc
// Function: ECC_GF28_evaluate(unsigned char const*, unsigned char, unsigned long)
uint8_t
ECC_GF28_evaluate(const uint8_t p[], uint8_t x, size_t n)
{
  uint8_t y = 1;
  uint8_t res = 0;
  
  for (size_t i = 0; i < n; i++) {
    res ^= ECC_GF28_multiply(p[i], y);
    y = ECC_GF28_multiply(y, x);
  }
  
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9373
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movzbl %al, %edi
movzbl -0x19(%rbp), %esi
callq 0x9250
movzbl %al, %ecx
movzbl -0x1a(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x1a(%rbp)
movb -0x19(%rbp), %al
movzbl %al, %edi
movzbl -0x9(%rbp), %esi
callq 0x9250
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9326
movb -0x1a(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/ECC_C2.cc
// Function: ECC_C2::ComputeSyndrome(unsigned char*)
bool
ECC_C2::ComputeSyndrome(uint8_t syndrome[ECC_C2::kTwoT])
{
  //
  // Multiply the filled in vector by the check matrix to produce a
  // result vector.
  //
  bool ok = true;
  for (size_t i = 0; i < kTwoT; i++) {
    uint8_t result = 0;
    for (size_t j = 0; j < kN; j++) {
      result ^= ECC_GF28_multiply(mData[j], gHq[i][j]);
    }

    syndrome[i] = result;

    //
    // Everything is ok if all previous entries are zero and this
    // entry is zero.
    //
    ok = ok && result == 0;
  }

  return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x6, -0x20(%rbp)
jae 0x9548
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x20, -0x30(%rbp)
jae 0x9509
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rcx
leaq 0x6318(%rip), %rax      # 0xf7f0
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movzbl %dl, %edi
movzbl (%rax,%rcx), %esi
callq 0x9250
movzbl %al, %ecx
movzbl -0x21(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x94bb
movb -0x21(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x39(%rbp)
je 0x952f
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x94a4
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/ECCFill_C1.cc
// Function: ECCFill_C1::CurrentPosition(unsigned int&, unsigned int&)
bool
ECCFill_C1::CurrentPosition(unsigned int& block, unsigned int& offset)
{
  if (End())
    return false;

  block = mBlockPairStart;
  offset = mInterleaveSet == EVEN ? 0 : 1;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xa018
jmp 0xa01e
movb $0x0, -0x1(%rbp)
jmp 0xa045
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movl 0x1c(%rax), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %edx
cmovel %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: ke6jjj[P]r-dat/ECCFill_C1.cc
// Function: ECCFill_C1::Next()
bool
ECCFill_C1::Next()
{
  if (End())
    return false;
  
  //
  // Choose the next interleave.
  //
  if (mInterleaveSet == ODD) {
    //
    // We're at the ODD set of the current block pair. We're done with
    // this block pair. Go to the EVEN set in the next pair.
    //
    mBlockPairStart += 2;
    mInterleaveSet = EVEN;
  } else {
    //
    // We're in the EVEN set. Go to the ODD set.
    //
    mInterleaveSet = ODD;
  }
  
  return !End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xa070
jmp 0xa076
movb $0x0, -0x1(%rbp)
jmp 0xa0b2
movq -0x18(%rbp), %rax
cmpl $0x1, 0x1c(%rax)
jne 0xa096
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x1c(%rax)
jmp 0xa0a1
movq -0x18(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/ECCFill_C1.cc
// Function: ECCFill_C1::Data(unsigned long)
uint8_t&
ECCFill_C1::Data(size_t position)
{
  size_t block, byte;
  
  compute_offsets(position, mInterleaveSet == ECCFill_C1::EVEN ? 0 : 1,
                  mBlockPairStart, block, byte);
  
  return mData[block][byte];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl 0x1c(%rax), %edx
movl $0x1, %esi
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %esi
movl 0x18(%rax), %edx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0xa140
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/ECCFill_C2.cc
// Function: ECCFill_C2::CurrentPosition(unsigned int&, unsigned int&)
bool
ECCFill_C2::CurrentPosition(unsigned int& group, unsigned int& slice)
{
  if (End())
    return false;

  group = mGroup;
  slice = mByteSlice;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xa378
jmp 0xa37e
movb $0x0, -0x1(%rbp)
jmp 0xa398
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/ECCFill_C2.cc
// Function: ECCFill_C2::Next()
bool
ECCFill_C2::Next()
{
  unsigned int maxSlice;
  
  if (End())
    return false;

  //
  // Determine the maximum byte slice number for the current group.
  //
  if ((mGroup & 1) == 0)
    maxSlice = kBytesEvenGroup;
  else
    maxSlice = kBytesOddGroup;
  
  if (mByteSlice == (maxSlice - 1)) {
    //
    // We're at the maximum slice for the current group. Move to the next
    // group.
    //
    mByteSlice = 0;
    mGroup++;
  } else {
    //
    // There are still more slices to process in the current group. Choose
    // the next one.
    //
    mByteSlice++;
  }
  
  return !End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xa3d0
jmp 0xa3d6
movb $0x0, -0x1(%rbp)
jmp 0xa43a
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xa3ee
movl $0x20, -0x14(%rbp)
jmp 0xa3f5
movl $0x18, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xa41c
movq -0x20(%rbp), %rax
movl $0x0, 0x18(%rax)
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0xa429
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/DDSSubcode.cc
// Function: DDSSubcodePack1::Decode(unsigned char const*)
void
DDSSubcodePack1::Decode(const uint8_t *bytes)
{
  uint8_t position;
  uint16_t group;
  uint32_t separator_1_count;
  bool changed;
  
  position = bytes[0] & 7;
  group = DecodeU16(&bytes[1]);
  separator_1_count = DecodeU32(&bytes[3]);
  
  mValid = true;
  mPosition = position;
  mGroup = group;
  mSeparator1Count = separator_1_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xa590
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x3, %rdi
callq 0xa5b0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movb $0x1, (%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x1(%rax)
movw -0x14(%rbp), %cx
movw %cx, 0x2(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/DDSSubcode.cc
// Function: DecodeU32(unsigned char const*)
static uint32_t
DecodeU32(const uint8_t *bytes)
{
  return (bytes[0] << 24) |
         (bytes[1] << 16) |
         (bytes[2] <<  8) |
         (bytes[3]      );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: ke6jjj[P]r-dat/DDSSubcode.cc
// Function: DDSSubcodePack3::Decode(unsigned char const*)
void
DDSSubcodePack3::Decode(const uint8_t *bytes)
{
  uint8_t part;
  uint8_t area_id;
  uint32_t abs_frame_num;
  uint8_t csum1;
  uint8_t csum2;
  uint8_t lfid;
  bool is_last;
  
  part = (bytes[0] & 8) ? 1 : 0;
  area_id = bytes[0] & 7;
  abs_frame_num = DecodeU24(&bytes[1]);
  csum1 = bytes[4];
  csum2 = bytes[5];
  lfid = bytes[6];
  
  mValid = true;
  mPartitionID = part;
  mAreaID = area_id;
  mAbsoluteFrameID = abs_frame_num;
  mChecksum1 = csum1;
  mChecksum2 = csum2;
  mLogicalFrameID = lfid & 0x3f;
  mIsLastLogicalFrame = (lfid & 0x80) == 0x80;
  mIsECC3Frame = (lfid & 0x40) == 0x40;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edx
andl $0x8, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x7, %eax
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xa730
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb 0x4(%rcx), %cl
movb %cl, -0x19(%rbp)
movq -0x10(%rbp), %rcx
movb 0x5(%rcx), %cl
movb %cl, -0x1a(%rbp)
movq -0x10(%rbp), %rcx
movb 0x6(%rcx), %cl
movb %cl, -0x1b(%rbp)
movb $0x1, (%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x1(%rax)
movb -0x12(%rbp), %cl
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movb -0x19(%rbp), %cl
movb %cl, 0x8(%rax)
movb -0x1a(%rbp), %cl
movb %cl, 0x9(%rax)
movzbl -0x1b(%rbp), %ecx
andl $0x3f, %ecx
movb %cl, 0xa(%rax)
movzbl -0x1b(%rbp), %ecx
andl $0x80, %ecx
cmpl $0x80, %ecx
sete %cl
andb $0x1, %cl
movb %cl, 0xb(%rax)
movzbl -0x1b(%rbp), %ecx
andl $0x40, %ecx
cmpl $0x40, %ecx
sete %cl
andb $0x1, %cl
movb %cl, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: ke6jjj[P]r-dat/File.cc
// Function: File::Close()
void
File::Close()
{
  if (!mOpen)
    return;

  ::close(mFd);
  
  mOpen = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, (%rax)
jne 0xab3b
jmp 0xab4e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x2200
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/File.cc
// Function: File::Open(char const*, unsigned long)
bool
File::Open(const char *path, size_t quanta)
{
  mFd = ::open(path, O_RDONLY);
  if (mFd == -1)
    return false;

  mOpen = true;
  Reset(quanta);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x20c0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $-0x1, 0x4(%rax)
jne 0xab9e
movb $0x0, -0x1(%rbp)
jmp 0xabb2
movq -0x28(%rbp), %rdi
movb $0x1, (%rdi)
movq -0x20(%rbp), %rsi
callq 0xabc0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/File.cc
// Function: File::Reset(unsigned long)
void
File::Reset(size_t quanta)
{
  delete mResidual;
  mQuanta = quanta;
  mResidual = new char[mQuanta];
  mResidualCount = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xabf4
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2100
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/File.cc
// Function: File::Open(int, unsigned long)
bool
File::Open(int fd, size_t quanta)
{
  mFd = fd;
  if (mFd == -1)
    return false;

  mOpen = true;
  Reset(quanta);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
cmpl $-0x1, 0x4(%rax)
jne 0xac5d
movb $0x0, -0x1(%rbp)
jmp 0xac71
movq -0x28(%rbp), %rdi
movb $0x1, (%rdi)
movq -0x20(%rbp), %rsi
callq 0xabc0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/File.cc
// Function: File::Read(void*, unsigned long)
size_t
File::Read(void *buf, size_t count)
{
  char *cbuf = (char *) buf;

  if (!mOpen)
    return 0;

  if (count == 0)
    return 0;
  
  size_t total = count * mQuanta;

  //
  // Copy in any residual data first.
  //
  if (mResidualCount > 0) {
    memcpy(cbuf, mResidual, mResidualCount);
    total -= mResidualCount;
  }

  size_t pos = mResidualCount;

  while (total > 0) {
    int nread = ::read(mFd, &cbuf[pos], total);
    if (nread == -1 || nread == 0) {
      //
      // Some sort of error occurred. Probably a signal.
      //
      break;
    }
    total -= nread;
    pos += nread;
  }

  //
  // Is there any residual data?
  //
  size_t residue = pos % mQuanta;
  if (residue != 0) {
    memcpy(mResidual, &cbuf[pos - residue], residue);
    pos -= residue;
  }

  mResidualCount = residue;

  return pos / mQuanta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
testb $0x1, (%rax)
jne 0xacb6
movq $0x0, -0x8(%rbp)
jmp 0xadc5
cmpq $0x0, -0x20(%rbp)
jne 0xacca
movq $0x0, -0x8(%rbp)
jmp 0xadc5
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x0, 0x18(%rax)
jbe 0xad0a
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x20d0
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0xad63
movq -0x50(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x28(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x21a0
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
je 0xad44
cmpl $0x0, -0x3c(%rbp)
jne 0xad46
jmp 0xad63
movslq -0x3c(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movslq -0x3c(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xad16
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xadab
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rax
subq -0x48(%rbp), %rax
addq %rax, %rsi
movq -0x48(%rbp), %rdx
callq 0x20d0
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rax, 0x18(%rcx)
movq -0x38(%rbp), %rax
xorl %edx, %edx
divq 0x10(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: ke6jjj[P]r-dat/BasicGroup.cc
// Function: BasicGroup::BasicGroup(unsigned int)
BasicGroup::BasicGroup(uint32_t id)
  : mBasicGroupID(id)
{
  for (size_t i = 0; i < kSize; i++) {
    mData[i] = 0;
    mDataIsValid[i] = false;
  }
  
  for (size_t i = 0; i < DDSGroup1::kSize; i++) {
    mECCData[i] = 0;
    mECCDataIsValid[i] = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq $0x0, -0x18(%rbp)
cmpq $0x1eea8, -0x18(%rbp)   # imm = 0x1EEA8
jae 0xae21
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x4(%rax,%rcx)
movq -0x18(%rbp), %rcx
movb $0x0, 0x1eeac(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xadf0
movq $0x0, -0x20(%rbp)
cmpq $0x167c, -0x20(%rbp)    # imm = 0x167C
jae 0xae5d
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, 0x3dd54(%rax,%rcx)
movq -0x20(%rbp), %rcx
movb $0x0, 0x3f3d0(%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xae29
popq %rbp
retq
nop
// File: ke6jjj[P]r-dat/BasicGroup.cc
// Function: BasicGroup::Correct()
bool
BasicGroup::Correct()
{
  ECC_C3 C3;
  size_t uncorrectableErrors = 0;
  
  for (ECCFill_C3 c3_fill(*this); !c3_fill.End(); c3_fill.Next()) {
    //
    // Fill the error check vector.
    //      
    C3.Fill(c3_fill);

    //
    // Detect errors in this vector and correct them.
    //
    ECC_C3::Status ok = C3.Correct();
    switch (ok) {
    case ECC_C3::NO_ERRORS:
      //
      // No errors. Nothing to be done.
      //
      break;
    case ECC_C3::CORRECTED:
      //
      // There were errors but they were corrected.
      // Put the corrected data back into the track.
      //
      C3.Dump(c3_fill);
      break;
    case ECC_C3::UNCORRECTABLE:
      //
      // Slice was uncorrectable. Leave it as is.
      //
      uncorrectableErrors++;
      break;
    }
  }
  
  return uncorrectableErrors == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x64(%rbp), %rdi
callq 0xbbb0
movq -0xc0(%rbp), %rsi
movq $0x0, -0x70(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xb820
jmp 0xb5b0
jmp 0xb5b2
leaq -0xa8(%rbp), %rdi
callq 0xb9e0
movb %al, -0xc1(%rbp)
jmp 0xb5c6
movb -0xc1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb61d
leaq -0xa8(%rbp), %rdi
callq 0xb800
jmp 0xb6af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xb6d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xb800
jmp 0xb6d7
leaq -0x64(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xbc00
jmp 0xb62f
leaq -0x64(%rbp), %rdi
callq 0xbd50
movl %eax, -0xc8(%rbp)
jmp 0xb640
movl -0xc8(%rbp), %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0xcc(%rbp)
testl %eax, %eax
je 0xb678
jmp 0xb65e
movl -0xcc(%rbp), %eax
subl $0x1, %eax
je 0xb67a
jmp 0xb66b
movl -0xcc(%rbp), %eax
subl $0x2, %eax
je 0xb68e
jmp 0xb69a
jmp 0xb69a
leaq -0x64(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xc0b0
jmp 0xb68c
jmp 0xb69a
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xb69c
leaq -0xa8(%rbp), %rdi
callq 0xb920
jmp 0xb6aa
jmp 0xb5b2
cmpq $0x0, -0x70(%rbp)
sete %al
movb %al, -0xcd(%rbp)
leaq -0x64(%rbp), %rdi
callq 0xbbf0
movb -0xcd(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x64(%rbp), %rdi
callq 0xbbf0
movq -0xb0(%rbp), %rdi
callq 0x21d0
nopl (%rax)
// File: ke6jjj[P]r-dat/ECCFill_C3.cc
// Function: ECCFill_C3::Next()
bool
ECCFill_C3::Next()
{
  unsigned int maxTrackPair;
  
  if (End())
    return false;

  //
  // Determine the maximum track pair for the current byte slice.
  //
  if (mByteSlice < (kByteSlices - 1)) {
    //
    // Every byte slice except the last has two track pairs.
    //
    maxTrackPair = 2;
  } else {
    //
    // The last byte slice only has one track pair.
    //
    maxTrackPair = 1;
  }
  
  //
  // Go to the next interleave set in the track pair.
  //
  if (mInterleaveSet == (kInterleaves - 1)) {
    //
    // We're finished with this track pair. Move to the next track
    // pair.
    //
    if (mTrackPair == (maxTrackPair - 1)) {
      //
      // We're finished with the track pairs in this byte slice. Move to
      // the next byte slice.
      //
      mByteSlice++;
      mTrackPair = 0;
    } else {
      mTrackPair++;
    }
    mInterleaveSet = 0;
  } else {
    mInterleaveSet++;
  }
  
  return !End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0xb940
jmp 0xb949
movb $0x0, -0x1(%rbp)
jmp 0xb9cf
movq -0x20(%rbp), %rax
cmpl $0x2cf, 0x28(%rax)      # imm = 0x2CF
jae 0xb95f
movl $0x2, -0x14(%rbp)
jmp 0xb966
movl $0x1, -0x14(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xb9b1
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb997
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movl $0x0, 0x2c(%rax)
jmp 0xb9a4
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
jmp 0xb9be
movq -0x20(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/ECCFill_C3.cc
// Function: ECCFill_C3::Data(unsigned long)
uint8_t&
ECCFill_C3::Data(size_t position)
{
  bool isECC;
  const size_t offset = compute_offset(position, mByteSlice, mTrackPair,
    mInterleaveSet, isECC);
  
  if (!isECC)
    return mData[offset];
  else
    return mECCData[offset];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movl 0x30(%rax), %ecx
leaq -0x19(%rbp), %r8
callq 0xba70
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xba4a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xba5a
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/ECCFill_C3.cc
// Function: compute_offset(unsigned long, unsigned int, unsigned int, unsigned int, bool&)
static inline size_t
compute_offset(size_t position, unsigned int byteSlice, unsigned int trackPair,
               unsigned int interleave, bool& isECC)
{
  const size_t g1_group = position / 2;
  size_t g1_offset;
  
  if (g1_group == 22) {
    //
    // The ECC group is stored in a separate array, so its offset is actually
    // zero within that array.
    //
    g1_offset = 0;
    isECC = true;
  } else {
    g1_offset = g1_group * DDSGroup1::kSize;
    isECC = false;
  }
  
  if ((position & 1) == 0) {
    return 8 * byteSlice + 2 * (trackPair + 1) + interleave + g1_offset;
  } else {
    return 8 * byteSlice + 6 * trackPair + interleave + g1_offset;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x30(%rbp)
cmpq $0x16, -0x30(%rbp)
jne 0xbaa8
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
jmp 0xbabb
imulq $0x167c, -0x30(%rbp), %rax # imm = 0x167C
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xbae8
movl -0x14(%rbp), %eax
shll $0x3, %eax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
shll %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, %eax
addq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbb01
movl -0x14(%rbp), %eax
shll $0x3, %eax
imull $0x6, -0x18(%rbp), %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, %eax
addq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/ECCFill_C3.cc
// Function: ECCFill_C3::Valid(unsigned long)
bool&
ECCFill_C3::Valid(size_t position)
{
  bool isECC;
  const size_t offset = compute_offset(position, mByteSlice, mTrackPair,
    mInterleaveSet, isECC);

  if (!isECC)
    return mDataIsValid[offset];
  else
    return mECCDataIsValid[offset];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl 0x28(%rax), %esi
movl 0x2c(%rax), %edx
movl 0x30(%rax), %ecx
leaq -0x19(%rbp), %r8
callq 0xba70
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xbb5a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbb6a
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ke6jjj[P]r-dat/ECC_C3.cc
// Function: ECC_C3::ComputeSyndrome(unsigned char*)
bool
ECC_C3::ComputeSyndrome(uint8_t syndrome[ECC_C3::kTwoT])
{
  //
  // Multiply the filled in vector by the check matrix to produce a
  // result vector.
  //
  bool ok = true;
  for (size_t i = 0; i < kTwoT; i++) {
    uint8_t result = 0;
    for (size_t j = 0; j < kN; j++) {
      result ^= ECC_GF28_multiply(mData[j], gHi[i][j]);
    }

    syndrome[i] = result;

    //
    // Everything is ok if all previous entries are zero and this
    // entry is zero.
    //
    ok = ok && result == 0;
  }

  return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0xbd45
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x2e, -0x30(%rbp)
jae 0xbd06
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
leaq 0x3ecc(%rip), %rax      # 0xfba0
imulq $0x2e, -0x20(%rbp), %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movzbl %dl, %edi
movzbl (%rax,%rcx), %esi
callq 0x9250
movzbl %al, %ecx
movzbl -0x21(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xbcbb
movb -0x21(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x39(%rbp)
je 0xbd2c
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbca4
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: ke6jjj[P]r-dat/XDR.cc
// Function: XDR::AddString(char const*, unsigned long)
bool
XDR::AddString(const char *str, size_t len)
{
  if (!SizeCheck(len))
    return false;
  
  memcpy(&mData[mPosition], str, len);
  mPosition += len;
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x20(%rbp), %rsi
callq 0xc790
testb $0x1, %al
jne 0xc74f
movb $0x0, -0x1(%rbp)
jmp 0xc77c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
addq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x20d0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ke6jjj[P]r-dat/XDR.cc
// Function: XDR::AddI16(short)
bool
XDR::AddI16(int16_t i)
{
  if (!SizeCheck(2))
    return false;
  
  mData[mPosition] = (i & 0xff);
  mData[mPosition+1] = (i >> 8) & 0xff;
  mPosition += 2;
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x2, %esi
callq 0xc790
testb $0x1, %al
jne 0xc7ef
movb $0x0, -0x1(%rbp)
jmp 0xc839
movq -0x20(%rbp), %rax
movswl -0x12(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, (%rcx,%rdx)
movswl -0x12(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, 0x1(%rcx,%rdx)
movq 0x8(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/XDR.cc
// Function: XDR::AddU16(unsigned short)
bool
XDR::AddU16(uint16_t i)
{
  if (!SizeCheck(2))
    return false;
  
  mData[mPosition] = (i & 0xff);
  mData[mPosition+1] = (i >> 8) & 0xff;
  mPosition += 2;
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x2, %esi
callq 0xc790
testb $0x1, %al
jne 0xc87f
movb $0x0, -0x1(%rbp)
jmp 0xc8c9
movq -0x20(%rbp), %rax
movzwl -0x12(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, (%rcx,%rdx)
movzwl -0x12(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, 0x1(%rcx,%rdx)
movq 0x8(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ke6jjj[P]r-dat/XDR.cc
// Function: XDR::AddI32(int)
bool
XDR::AddI32(int32_t i)
{
  if (!SizeCheck(4))
    return false;
  
  mData[mPosition] = (i & 0xff);
  mData[mPosition+1] = (i >> 8) & 0xff;
  mData[mPosition+2] = (i >> 16) & 0xff;
  mData[mPosition+3] = (i >> 24) & 0xff;
  mPosition += 4;
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x4, %esi
callq 0xc790
testb $0x1, %al
jne 0xc90e
movb $0x0, -0x1(%rbp)
jmp 0xc98e
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, (%rcx,%rdx)
movl -0x14(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, 0x1(%rcx,%rdx)
movl -0x14(%rbp), %ecx
sarl $0x10, %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, 0x2(%rcx,%rdx)
movl -0x14(%rbp), %ecx
sarl $0x18, %ecx
andl $0xff, %ecx
movb %cl, %sil
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rdx
movb %sil, 0x3(%rcx,%rdx)
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/TimeCode.cc
// Function: TimeCode::TimeCode(unsigned char const*)
TimeCode::TimeCode(const uint8_t *item)
{
  uint8_t pno1 = item[0] & 0x7;
  uint8_t pno23 = item[1];
  
  //
  // Process the program number bits. Certain patterns are
  // special.
  //
  switch (pno23) {
  case 0xaa:
    mProgramId = PROGRAM_NOT_VALID;
    break;
  case 0xbb:
    mProgramId = PROGRAM_LEAD_IN;
    break;
  case 0xee:
    mProgramId = PROGRAM_LEAD_OUT;
    break;
  default:
    mProgramId = ((uint16_t) BCDDecode(pno23)) + 100 * pno1;
    break;
  }
  
  //
  // Process the index id bits.
  //
  uint8_t index_id = item[2];
  if (index_id == 0xaa)
    mIndexId = INDEX_NOT_VALID;
  else
    mIndexId = BCDDecode(item[2]);
  
  mHour = BCDDecode(item[3]);
  mMinute = BCDDecode(item[4]);
  mSecond = BCDDecode(item[5]);
  mFrame = BCDDecode(item[6]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
andb $0x7, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0xaa, %eax
je 0xcb15
jmp 0xcafd
movl -0x18(%rbp), %eax
subl $0xbb, %eax
je 0xcb20
jmp 0xcb09
movl -0x18(%rbp), %eax
subl $0xee, %eax
je 0xcb2b
jmp 0xcb36
movq -0x20(%rbp), %rax
movw $0x80aa, (%rax)         # imm = 0x80AA
jmp 0xcb5a
movq -0x20(%rbp), %rax
movw $0x80bb, (%rax)         # imm = 0x80BB
jmp 0xcb5a
movq -0x20(%rbp), %rax
movw $0x80ee, (%rax)         # imm = 0x80EE
jmp 0xcb5a
movzbl -0x12(%rbp), %eax
movzwl %ax, %edi
callq 0xce20
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
movzwl %cx, %ecx
movzbl -0x11(%rbp), %edx
imull $0x64, %edx, %edx
addl %edx, %ecx
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x13(%rbp)
movzbl -0x13(%rbp), %eax
cmpl $0xaa, %eax
jne 0xcb79
movq -0x20(%rbp), %rax
movb $-0x56, 0x2(%rax)
jmp 0xcb92
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %edi
callq 0xce20
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movzwl %ax, %edi
callq 0xce20
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movzwl %ax, %edi
callq 0xce20
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
movzwl %ax, %edi
callq 0xce20
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
movzwl %ax, %edi
callq 0xce20
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x6(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ke6jjj[P]r-dat/TimeCode.cc
// Function: TimeCode::TimeCode(unsigned int)
TimeCode::TimeCode(uint32_t absoluteFrame)
  : mIndexId(INDEX_NOT_VALID), mProgramId(PROGRAM_NOT_VALID)
{
  //
  // There are 120000 frames an hour.
  //
  mHour = absoluteFrame / 120000;
  absoluteFrame %= 120000;
  
  //
  // There are 2000 frames every minute.
  //
  mMinute = absoluteFrame / 2000;
  absoluteFrame %= 2000;
  
  //
  // There are 100 frames every three seconds.
  //
  uint8_t second = (absoluteFrame / 100) * 3;
  absoluteFrame %= 100;
  second += absoluteFrame / 33;
  uint8_t frame = absoluteFrame % 33;
  second -= absoluteFrame / 99;
  frame += (absoluteFrame / 99) * 33;
  mSecond = second;
  mFrame = frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x80aa, (%rax)         # imm = 0x80AA
movb $-0x56, 0x2(%rax)
movl -0xc(%rbp), %eax
movl $0x1d4c0, %ecx          # imm = 0x1D4C0
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0xc(%rbp), %eax
movl $0x1d4c0, %ecx          # imm = 0x1D4C0
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x7d0, %ecx            # imm = 0x7D0
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0xc(%rbp), %eax
movl $0x7d0, %ecx            # imm = 0x7D0
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
imull $0x3, %eax, %eax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x21, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movzbl -0xd(%rbp), %eax
addl %ecx, %eax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
movl $0x21, %ecx
xorl %edx, %edx
divl %ecx
movb %dl, %al
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
movl $0x63, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movzbl -0xd(%rbp), %eax
subl %ecx, %eax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
movl $0x63, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
imull $0x21, %ecx, %edx
movzbl -0xe(%rbp), %ecx
addl %edx, %ecx
movb %cl, -0xe(%rbp)
movb -0xd(%rbp), %cl
movb %cl, 0x5(%rax)
movb -0xe(%rbp), %cl
movb %cl, 0x6(%rax)
popq %rbp
retq