LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderSetLimitTimeRange
void fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_time)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;

if(xc)
        {
        xc->limit_range_valid = 1;
        xc->limit_range_start = start_time;
        xc->limit_range_end = end_time;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaeed
movq -0x20(%rbp), %rax
movb 0x7a(%rax), %cl
andb $0x7f, %cl
orb $-0x80, %cl
movb %cl, 0x7a(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x1b0(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x1b8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderIterateHierRewind
int fstReaderIterateHierRewind(void *ctx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
int pass_status = 0;

if(xc)
        {
        pass_status = 1;
        if(!xc->fh)
                {
                pass_status = fstReaderRecreateHierFile(xc);
                }

        xc->do_rewind = 1;
        }

return(pass_status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaff6
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xafe0
movq -0x10(%rbp), %rdi
callq 0xb000
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb 0x294(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x294(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderVarint64
static uint64_t fstReaderVarint64(FILE *f)
{
unsigned char buf[16];
unsigned char *mem = buf;
uint64_t rc = 0;
int ch;

do
        {
        ch = fgetc(f);
        *(mem++) = ch;
        } while(ch & 0x80);
mem--;

for(;;)
        {
        rc <<= 7;
        rc |= (uint64_t)(*mem & 0x7f);
        if(mem == buf)
                {
                break;
                }
        mem--;
        }

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21a0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movl -0x34(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xbbcc
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
shlq $0x7, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
cltq
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
leaq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbc36
jmp 0xbc44
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xbc07
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstGetVarint64
static uint64_t fstGetVarint64(unsigned char *mem, int *skiplen)
{
unsigned char *mem_orig = mem;
uint64_t rc = 0;
while(*mem & 0x80)
        {
        mem++;
        }

*skiplen = mem - mem_orig + 1;
for(;;)
        {
        rc <<= 7;
        rc |= (uint64_t)(*mem & 0x7f);
        if(mem == mem_orig)
                {
                break;
                }
        mem--;
        }

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbc8b
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xbc6c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
shlq $0x7, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
cltq
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xbcce
jmp 0xbcdc
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xbca2
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderVarint32
static uint32_t fstReaderVarint32(FILE *f)
{
unsigned char buf[5];
unsigned char *mem = buf;
uint32_t rc = 0;
int ch;

do
        {
        ch = fgetc(f);
        *(mem++) = ch;
        } while(ch & 0x80);
mem--;

for(;;)
        {
        rc <<= 7;
        rc |= (uint32_t)(*mem & 0x7f);
        if(mem == buf)
                {
                break;
                }
        mem--;
        }

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xd(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21a0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x20(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xbd0b
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
shll $0x7, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
leaq -0xd(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbd6e
jmp 0xbd7c
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbd46
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstVcdID
static void fstVcdID(char *buf, unsigned int value)
{
char *pnt = buf;

/* zero is illegal for a value...it is assumed they start at one */
while (value)
        {
        value--;
        *(pnt++) = (char)('!' + value % 94);
        value = value / 94;
        }

*pnt = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xc825
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x5e, %ecx
xorl %edx, %edx
divl %ecx
addl $0x21, %edx
movb %dl, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
movl $0x5e, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
jmp 0xc7e3
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderUint64
static uint64_t fstReaderUint64(FILE *f)
{
uint64_t val = 0;
unsigned char buf[sizeof(uint64_t)];
unsigned int i;

fstFread(buf, sizeof(uint64_t), 1, f);
for(i=0;i<sizeof(uint64_t);i++)
        {
        val <<= 8;
        val |= buf[i];
        }

return(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x7990
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x8, %rax
jae 0xd522
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
movzbl -0x18(%rbp,%rax), %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd4f2
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstGetVarint32
static uint32_t fstGetVarint32(unsigned char *mem, int *skiplen)
{
unsigned char *mem_orig = mem;
uint32_t rc = 0;
while(*mem & 0x80)
        {
        mem++;
        }

*skiplen = mem - mem_orig + 1;
for(;;)
        {
        rc <<= 7;
        rc |= (uint32_t)(*mem & 0x7f);
        if(mem == mem_orig)
                {
                break;
                }
        mem--;
        }

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xd56a
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xd54b
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
shll $0x7, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xd5a6
jmp 0xd5b4
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xd581
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderOpen
void *fstReaderOpen(const char *nam)
{
struct fstReaderContext *xc = (struct fstReaderContext *)calloc(1, sizeof(struct fstReaderContext));

if((!nam)||(!(xc->f=fopen(nam, "rb"))))
        {
        free(xc);
        xc=NULL;
        }
        else
        {
        int flen = strlen(nam);
        char *hf = (char *)calloc(1, flen + 6);
        int rc;

#if defined(__MINGW32__) || defined(FST_MACOSX)
        setvbuf(xc->f, (char *)NULL, _IONBF, 0);   /* keeps gzip from acting weird in tandem with fopen */
#endif

        memcpy(hf, nam, flen);
        strcpy(hf + flen, ".hier");
        xc->fh = fopen(hf, "rb");

        free(hf);
        xc->filename = strdup(nam);
        rc = fstReaderInit(xc);

        if((rc) && (xc->vc_section_count) && (xc->maxhandle) && ((xc->fh)||(xc->contains_hier_section||(xc->contains_hier_section_lz4))))
                {
                /* more init */
                xc->do_rewind = 1;
                }
                else
                {
                fstReaderClose(xc);
                xc = NULL;
                }
        }

return(xc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x106b0, %esi          # imm = 0x106B0
callq 0x21f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd633
movq -0x8(%rbp), %rdi
leaq 0x1dbfa(%rip), %rsi     # 0x2b21b
callq 0x2330
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xd649
movq -0x10(%rbp), %rdi
callq 0x2040
movq $0x0, -0x10(%rbp)
jmp 0xd754
movq -0x8(%rbp), %rdi
callq 0x2130
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x6, %eax
movslq %eax, %rsi
movl $0x1, %edi
callq 0x21f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2250
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0x1d8b6(%rip), %rsi     # 0x2af45
callq 0x2090
movq -0x20(%rbp), %rdi
leaq 0x1db7c(%rip), %rsi     # 0x2b21b
callq 0x2330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x23a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x180(%rax)
movq -0x10(%rbp), %rdi
callq 0xc830
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xd741
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xd741
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0xd741
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd729
movq -0x10(%rbp), %rax
movb 0x7a(%rax), %al
shrb $0x4, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd729
movq -0x10(%rbp), %rax
movb 0x7a(%rax), %al
shrb $0x6, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xd741
movq -0x10(%rbp), %rax
movb 0x294(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x294(%rax)
jmp 0xd752
movq -0x10(%rbp), %rdi
callq 0xd760
movq $0x0, -0x10(%rbp)
jmp 0xd754
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderClose
void fstReaderClose(void *ctx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;

if(xc)
        {
        fstReaderDeallocateScopeData(xc);
        fstReaderDeallocateRvatData(xc);
        free(xc->rvat_sig_offs); xc->rvat_sig_offs = NULL;

        free(xc->process_mask); xc->process_mask = NULL;
        free(xc->blackout_times); xc->blackout_times = NULL;
        free(xc->blackout_activity); xc->blackout_activity = NULL;
        free(xc->temp_signal_value_buf); xc->temp_signal_value_buf = NULL;
        free(xc->signal_typs); xc->signal_typs = NULL;
        free(xc->signal_lens); xc->signal_lens = NULL;
        free(xc->filename); xc->filename = NULL;

        if(xc->fh)
                {
                tmpfile_close(&xc->fh, &xc->fh_nam);
                }

        if(xc->f)
                {
                tmpfile_close(&xc->f, &xc->f_nam);
                if(xc->filename_unpacked)
                        {
                        unlink(xc->filename_unpacked);
                        free(xc->filename_unpacked);
                        }
                }

        free(xc);
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd8eb
movq -0x10(%rbp), %rdi
callq 0xd900
movq -0x10(%rbp), %rdi
callq 0xd980
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x210(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x1a0(%rax)
movq -0x10(%rbp), %rax
movq 0x1a8(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x1a8(%rax)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x180(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd894
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x106a8, %rsi          # imm = 0x106A8
callq 0x4df0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd8e2
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x106a0, %rsi          # imm = 0x106A0
callq 0x4df0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x188(%rax)
je 0xd8e0
movq -0x10(%rbp), %rax
movq 0x188(%rax), %rdi
callq 0x2070
movq -0x10(%rbp), %rax
movq 0x188(%rax), %rdi
callq 0x2040
jmp 0xd8e2
movq -0x10(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderDeallocateScopeData
static void fstReaderDeallocateScopeData(struct fstReaderContext *xc)
{
struct fstCurrHier *chp;

free(xc->curr_flat_hier_nam); xc->curr_flat_hier_nam = NULL;
while(xc->curr_hier)
        {
        chp = xc->curr_hier->prev;
        free(xc->curr_hier);
        xc->curr_hier = chp;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x288(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0x288(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0xd96c
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x278(%rax)
jmp 0xd92b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderDeallocateRvatData
static void fstReaderDeallocateRvatData(void *ctx)
{
struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
if(xc)
        {
        free(xc->rvat_chain_mem); xc->rvat_chain_mem = NULL;
        free(xc->rvat_frame_data); xc->rvat_frame_data = NULL;
        free(xc->rvat_time_table); xc->rvat_time_table = NULL;
        free(xc->rvat_chain_table); xc->rvat_chain_table = NULL;
        free(xc->rvat_chain_table_lengths); xc->rvat_chain_table_lengths = NULL;

        xc->rvat_data_valid = 0;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xda50
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x1e0(%rax)
movq -0x10(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x1c8(%rax)
movq -0x10(%rbp), %rax
movq 0x1f0(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x1f0(%rax)
movq -0x10(%rbp), %rax
movq 0x1f8(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x1f8(%rax)
movq -0x10(%rbp), %rax
movb 0x1c0(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x1c0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstWritex
static void fstWritex(struct fstReaderContext *xc, void *v, int len)
{
unsigned char *s = (unsigned char *)v;

if(len)
        {
        if(len < FST_WRITEX_MAX)
                {
                if(xc->writex_pos + len >= FST_WRITEX_MAX)
                        {
                        fstWritex(xc, NULL, 0);
                        }

                memcpy(xc->writex_buf + xc->writex_pos, s, len);
                xc->writex_pos += len;
                }
                else
                {
                fstWritex(xc, NULL, 0);
                if (write(xc->writex_fd, s, len)) { };
                }
        }
        else
        {
        if(xc->writex_pos)
                {
                if(write(xc->writex_fd, xc->writex_buf, xc->writex_pos)) { };
                xc->writex_pos = 0;
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1040e
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jge 0x103dc
movq -0x8(%rbp), %rax
movl 0x698(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jl 0x103a1
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10350
movq -0x8(%rbp), %rdi
addq $0x6a0, %rdi            # imm = 0x6A0
movq -0x8(%rbp), %rax
movslq 0x698(%rax), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2250
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x698(%rax), %ecx
movl %ecx, 0x698(%rax)
jmp 0x1040c
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10350
movq -0x8(%rbp), %rax
movl 0x69c(%rax), %edi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x20e0
cmpq $0x0, %rax
je 0x1040a
jmp 0x1040a
jmp 0x1040c
jmp 0x10458
movq -0x8(%rbp), %rax
cmpl $0x0, 0x698(%rax)
je 0x10456
movq -0x8(%rbp), %rax
movl 0x69c(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x6a0, %rsi            # imm = 0x6A0
movq -0x8(%rbp), %rax
movslq 0x698(%rax), %rdx
callq 0x20e0
cmpq $0x0, %rax
je 0x10448
jmp 0x10448
movq -0x8(%rbp), %rax
movl $0x0, 0x698(%rax)
jmp 0x10458
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstVcdIDForFwrite
static int fstVcdIDForFwrite(char *buf, unsigned int value)
{
char *pnt = buf;

/* zero is illegal for a value...it is assumed they start at one */
while (value)
        {
        value--;
        *(pnt++) = (char)('!' + value % 94);
        value = value / 94;
        }

return(pnt - buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x104b5
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x5e, %ecx
xorl %edx, %edx
divl %ecx
addl $0x21, %edx
movb %dl, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
movl $0x5e, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
jmp 0x10473
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstGetSVarint64
static int64_t fstGetSVarint64(unsigned char *mem, int *skiplen)
{
unsigned char *mem_orig = mem;
int64_t rc = 0;
const int64_t one = 1;
const int siz = sizeof(int64_t) * 8;
int shift = 0;
unsigned char byt;

do      {
        byt = *(mem++);
        rc |= ((int64_t)(byt & 0x7f)) << shift;
        shift += 7;

        } while(byt & 0x80);

if((shift<siz) && (byt & 0x40))
        {
        rc |= -(one << shift); /* sign extend */
        }

*skiplen = mem - mem_orig;

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movl $0x40, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
andl $0x7f, %eax
cltq
movl -0x30(%rbp), %ecx
shlq %cl, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x30(%rbp)
movzbl -0x31(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x10502
cmpl $0x40, -0x30(%rbp)
jge 0x10573
movzbl -0x31(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x10573
movl -0x30(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstReaderVarint32WithSkip
static uint32_t fstReaderVarint32WithSkip(FILE *f, uint32_t *skiplen)
{
unsigned char buf[5];
unsigned char *mem = buf;
uint32_t rc = 0;
int ch;

do
        {
        ch = fgetc(f);
        *(mem++) = ch;
        } while(ch & 0x80);
*skiplen = mem - buf;
mem--;

for(;;)
        {
        rc <<= 7;
        rc |= (uint32_t)(*mem & 0x7f);
        if(mem == buf)
                {
                break;
                }
        mem--;
        }

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x15(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21a0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x28(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x105af
movq -0x20(%rbp), %rax
leaq -0x15(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
shll $0x7, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
leaq -0x15(%rbp), %rcx
cmpq %rcx, %rax
jne 0x10625
jmp 0x10633
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x105fd
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstGetVarint32NoSkip
static uint32_t fstGetVarint32NoSkip(unsigned char *mem)
{
unsigned char *mem_orig = mem;
uint32_t rc = 0;
while(*mem & 0x80)
        {
        mem++;
        }

for(;;)
        {
        rc <<= 7;
        rc |= (uint32_t)(*mem & 0x7f);
        if(mem == mem_orig)
                {
                break;
                }
        mem--;
        }

return(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x10676
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10657
jmp 0x10678
movl -0x14(%rbp), %eax
shll $0x7, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x1069d
jmp 0x106ab
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10678
movl -0x14(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstUtilityFreeEnumTable
void fstUtilityFreeEnumTable(struct fstETab *etab)
{
if(etab)
	{
	free(etab->literal_arr);
	free(etab->val_arr);
	free(etab->name);
	free(etab);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12c12
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstGetVarint32Length
static uint32_t fstGetVarint32Length(unsigned char *mem)
{
unsigned char *mem_orig = mem;

while(*mem & 0x80)
        {
        mem++;
        }

return(mem - mem_orig + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x12c4f
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x12c30
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstCopyVarint32ToLeft
static unsigned char *fstCopyVarint32ToLeft(unsigned char *pnt, uint32_t v)
{
unsigned char *spnt;
uint32_t nxt = v;
int cnt = 1;
int i;

while((nxt = nxt>>7)) /* determine len to avoid temp buffer copying to cut down on load-hit-store */
        {
        cnt++;
        }

pnt -= cnt;
spnt = pnt;
cnt--;

for(i=0;i<cnt;i++) /* now generate left to right as normal */
        {
        nxt = v>>7;
        *(spnt++) = ((unsigned char)v) | 0x80;
        v = nxt;
        }
*spnt = (unsigned char)v;

return(pnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x7, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x12c91
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12c78
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x12cff
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movzbl %al, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12cbf
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstWriterSVarint
static int fstWriterSVarint(FILE *handle, int64_t v)
{
unsigned char buf[15]; /* ceil(64/7) = 10 + sign byte padded way up */
unsigned char byt;
unsigned char *pnt = buf;
int more = 1;
int len;

do      {
        byt = v | 0x80;
        v >>= 7;

        if (((!v) && (!(byt & 0x40))) || ((v == -1) && (byt & 0x40)))
                {
                more = 0;
                byt &= 0x7f;
                }

        *(pnt++) = byt;
        } while(more);

len = pnt-buf;
fstFwrite(buf, len, 1, handle);
return(len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1f(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x10(%rbp), %rax
orq $0x80, %rax
movb %al, -0x20(%rbp)
movq -0x10(%rbp), %rax
sarq $0x7, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12d5b
movzbl -0x20(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x12d6e
cmpq $-0x1, -0x10(%rbp)
jne 0x12d7f
movzbl -0x20(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x12d7f
movl $0x0, -0x2c(%rbp)
movzbl -0x20(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x20(%rbp)
movb -0x20(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
cmpl $0x0, -0x2c(%rbp)
jne 0x12d2f
movq -0x28(%rbp), %rax
leaq -0x1f(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x30(%rbp)
leaq -0x1f(%rbp), %rdi
movslq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x78b0
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstWriterSetAttrDoubleArgGeneric
static void fstWriterSetAttrDoubleArgGeneric(void *ctx, int typ, uint64_t arg1, uint64_t arg2)
{
struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
if(xc)
        {
        unsigned char buf[11]; /* ceil(64/7) = 10 + null term */
        unsigned char *pnt = fstCopyVarint64ToRight(buf, arg1);
        if(arg1)
                {
                *pnt = 0; /* this converts any *nonzero* arg1 when made a varint into a null-term string */
                }

        fstWriterSetAttrBegin(xc, FST_AT_MISC, typ, (char *)buf, arg2);
        }
}

// 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 -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12e3b
leaq -0x33(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12e50
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12e25
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x33(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %esi, %esi
callq 0x8b10
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/fstapi.c
// Function: fstCopyVarint64ToRight
static unsigned char *fstCopyVarint64ToRight(unsigned char *pnt, uint64_t v)
{
uint64_t nxt;

while((nxt = v>>7))
        {
        *(pnt++) = ((unsigned char)v) | 0x80;
        v = nxt;
        }
*(pnt++) = (unsigned char)v;

return(pnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x7, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x12e97
movq -0x10(%rbp), %rax
movzbl %al, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x12e5c
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_compress_destSize_extState
static int LZ4_compress_destSize_extState (void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
{
    LZ4_resetStream((LZ4_stream_t*)state);

    if (targetDstSize >= LZ4_compressBound(*srcSizePtr))   /* compression success is guaranteed */
    {
        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
    }
    else
    {
        if (*srcSizePtr < LZ4_64Klimit)
            return LZ4_compress_destSize_generic(state, src, dst, srcSizePtr, targetDstSize, byU16);
        else
            return LZ4_compress_destSize_generic(state, src, dst, srcSizePtr, targetDstSize, LZ4_64bits() ? byU32 : byPtr);
    }
}

// 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)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16100
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x12ed0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jl 0x17ab8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl -0x2c(%rbp), %r8d
movl $0x1, %r9d
callq 0x12f20
movl %eax, -0x4(%rbp)
jmp 0x17b42
movq -0x28(%rbp), %rax
cmpl $0x1000b, (%rax)        # imm = 0x1000B
jge 0x17ae8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl $0x2, %r9d
callq 0x28920
movl %eax, -0x4(%rbp)
jmp 0x17b42
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x16130
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %r8d
movl %eax, %r10d
xorl %r9d, %r9d
movl $0x1, %eax
cmpl $0x0, %r10d
cmovnel %eax, %r9d
callq 0x28920
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_loadDict
int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
{
    LZ4_stream_t_internal* dict = (LZ4_stream_t_internal*) LZ4_dict;
    const BYTE* p = (const BYTE*)dictionary;
    const BYTE* const dictEnd = p + dictSize;
    const BYTE* base;

    if ((dict->initCheck) || (dict->currentOffset > 1 GB))  /* Uninitialized structure, or reuse overflow */
        LZ4_resetStream(LZ4_dict);

    if (dictSize < (int)HASH_UNIT)
    {
        dict->dictionary = NULL;
        dict->dictSize = 0;
        return 0;
    }

    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
    dict->currentOffset += 64 KB;
    base = p - dict->currentOffset;
    dict->dictionary = p;
    dict->dictSize = (U32)(dictEnd - p);
    dict->currentOffset += dict->dictSize;

    while (p <= dictEnd-HASH_UNIT)
    {
        LZ4_putPosition(p, dict->hashTable, byU32, base);
        p+=3;
    }

    return dict->dictSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4004(%rax)
jne 0x17bef
movq -0x28(%rbp), %rax
cmpl $0x40000000, 0x4000(%rax) # imm = 0x40000000
jbe 0x17bf8
movq -0x10(%rbp), %rdi
callq 0x16100
cmpl $0x8, -0x1c(%rbp)
jge 0x17c27
movq -0x28(%rbp), %rax
movq $0x0, 0x4008(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x4018(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x17cfc
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
cmpq $0x10000, %rax          # imm = 0x10000
jle 0x17c48
movq -0x38(%rbp), %rax
addq $-0x10000, %rax         # imm = 0xFFFF0000
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x4000(%rax), %ecx
addl $0x10000, %ecx          # imm = 0x10000
movl %ecx, 0x4000(%rax)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x4000(%rcx), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x4008(%rax)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4018(%rax)
movq -0x28(%rbp), %rax
movl 0x4018(%rax), %ecx
movq -0x28(%rbp), %rax
addl 0x4000(%rax), %ecx
movl %ecx, 0x4000(%rax)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
ja 0x17cef
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rcx
movl $0x1, %edx
callq 0x17d10
movq -0x30(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x30(%rbp)
jmp 0x17cba
movq -0x28(%rbp), %rax
movl 0x4018(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_renormDictT
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
{
    if ((LZ4_dict->currentOffset > 0x80000000) ||
        ((size_t)LZ4_dict->currentOffset > (size_t)src))   /* address space overflow */
    {
        /* rescale hash table */
        U32 delta = LZ4_dict->currentOffset - 64 KB;
        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
        int i;
        for (i=0; i<HASH_SIZE_U32; i++)
        {
            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
            else LZ4_dict->hashTable[i] -= delta;
        }
        LZ4_dict->currentOffset = 64 KB;
        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x80000000, 0x4000(%rax) # imm = 0x80000000
ja 0x1b103
movq -0x8(%rbp), %rax
movl 0x4000(%rax), %eax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x1b1d1
movq -0x8(%rbp), %rax
movl 0x4000(%rax), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x4008(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x4018(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1000, -0x24(%rbp)    # imm = 0x1000
jge 0x1b182
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jae 0x1b162
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x1b175
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
subl %esi, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x1b177
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b138
movq -0x8(%rbp), %rax
movl $0x10000, 0x4000(%rax)  # imm = 0x10000
movq -0x8(%rbp), %rax
cmpl $0x10000, 0x4018(%rax)  # imm = 0x10000
jbe 0x1b1ae
movq -0x8(%rbp), %rax
movl $0x10000, 0x4018(%rax)  # imm = 0x10000
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x4018(%rax), %eax
movl %eax, %edx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4008(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_saveDict
int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
{
    LZ4_stream_t_internal* dict = (LZ4_stream_t_internal*) LZ4_dict;
    const BYTE* previousDictEnd = dict->dictionary + dict->dictSize;

    if ((U32)dictSize > 64 KB) dictSize = 64 KB;   /* useless to define a dictionary > 64 KB */
    if ((U32)dictSize > dict->dictSize) dictSize = dict->dictSize;

    memmove(safeBuffer, previousDictEnd - dictSize, dictSize);

    dict->dictionary = (const BYTE*)safeBuffer;
    dict->dictSize = (U32)dictSize;

    return dictSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x4008(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4018(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jbe 0x1bde7
movl $0x10000, -0x14(%rbp)   # imm = 0x10000
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4018(%rcx), %eax
jbe 0x1be03
movq -0x20(%rbp), %rax
movl 0x4018(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x22f0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x4008(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4018(%rax)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_setStreamDecode
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
{
    LZ4_streamDecode_t_internal* lz4sd = (LZ4_streamDecode_t_internal*) LZ4_streamDecode;
    lz4sd->prefixSize = (size_t) dictSize;
    lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
    lz4sd->externalDict = NULL;
    lz4sd->extDictSize  = 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_putPositionOnHash
static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t const tableType, const BYTE* srcBase)
{
    switch (tableType)
    {
    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0x283b6
jmp 0x283a2
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0x283cf
jmp 0x283ac
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x283f0
jmp 0x28411
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdx
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x28411
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x28411
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movw %ax, %dx
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_wildCopy
static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)
{
    BYTE* d = (BYTE*)dstPtr;
    const BYTE* s = (const BYTE*)srcPtr;
    BYTE* e = (BYTE*)dstEnd;
    do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x28840
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x2846c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_writeLE16
static void LZ4_writeLE16(void* memPtr, U16 value)
{
    if (LZ4_isLittleEndian())
    {
        memcpy(memPtr, &value, 2);
    }
    else
    {
        BYTE* p = (BYTE*)memPtr;
        p[0] = (BYTE) value;
        p[1] = (BYTE)(value>>8);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
callq 0x28860
cmpl $0x0, %eax
je 0x284da
movq -0x8(%rbp), %rax
movw -0xa(%rbp), %cx
movw %cx, (%rax)
jmp 0x284fe
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw -0xa(%rbp), %ax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_count
static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
{
    const BYTE* const pStart = pIn;

    while (likely(pIn<pInLimit-(STEPSIZE-1)))
    {
        size_t diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
        pIn += LZ4_NbCommonBytes(diff);
        return (unsigned)(pIn - pStart);
    }

    if (LZ4_64bits()) if ((pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
    return (unsigned)(pIn - pStart);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x7, %rcx
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x285c6
movq -0x18(%rbp), %rdi
callq 0x28740
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28740
movq %rax, %rcx
movq -0x38(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2859b
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x2852c
movq -0x30(%rbp), %rdi
callq 0x28880
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x2869d
callq 0x16130
cmpl $0x0, %eax
je 0x28619
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jae 0x28617
movq -0x18(%rbp), %rdi
callq 0x28420
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28420
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x28617
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x28619
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jae 0x28667
movq -0x18(%rbp), %rdi
callq 0x28900
movzwl %ax, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28900
movw %ax, %cx
movl -0x40(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jne 0x28667
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2868f
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2868f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bluecmd[P]fst-example/gtkwave/lz4.c
// Function: LZ4_readLE16
static U16 LZ4_readLE16(const void* memPtr)
{
    if (LZ4_isLittleEndian())
    {
        return LZ4_read16(memPtr);
    }
    else
    {
        const BYTE* p = (const BYTE*)memPtr;
        return (U16)((U16)p[0] + (p[1]<<8));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x28860
cmpl $0x0, %eax
je 0x29165
movq -0x10(%rbp), %rdi
callq 0x28900
movw %ax, -0x2(%rbp)
jmp 0x29188
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)