LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: SetModelNumbers()
static void     SetModelNumbers()
{
    int             i;
    int             models;
    char            value[10];

    models = 1;
    for (i = 1; i < g_numentities; i++)
    {
        if (g_entities[i].numbrushes)
        {
            safe_snprintf(value, sizeof(value), "*%i", models);
            models++;
            SetKeyValue(&g_entities[i], "model", value);
        }
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x1, 0x10(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
leaq 0x200cbc5(%rip), %rcx   # 0x202d4a4
cmpl (%rcx), %eax
jge 0x20959
movslq 0x14(%rsp), %rcx
leaq 0x200cbc1(%rip), %rax   # 0x202d4b0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x1c(%rax)
je 0x20947
leaq 0x6(%rsp), %rdi
movl 0x10(%rsp), %ecx
movl $0xa, %esi
leaq 0x9df5(%rip), %rdx      # 0x2a706
movb $0x0, %al
callq 0x99e0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movslq 0x14(%rsp), %rax
leaq 0x200cb81(%rip), %rdi   # 0x202d4b0
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x6(%rsp), %rdx
leaq 0xd71e(%rip), %rsi      # 0x2e060
callq 0x8070
jmp 0x20949
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x208d4
addq $0x18, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: ConvertHintToEmpty()
static void     ConvertHintToEmpty()
{
    int             i;

    // Convert HINT brushes to EMPTY after they have been carved by csg
    for (i = 0; i < MAX_MAP_BRUSHES; i++)
    {
        if (g_mapbrushes[i].contents == CONTENTS_HINT)
        {
            g_mapbrushes[i].contents = CONTENTS_EMPTY;
        }
    }
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x8000, -0x4(%rsp)     # imm = 0x8000
jge 0x20d2a
movslq -0x4(%rsp), %rcx
leaq 0x30ba952(%rip), %rax   # 0x30db640
imulq $0x140, %rcx, %rcx      # imm = 0x140
addq %rcx, %rax
cmpl $-0x10, 0x58(%rax)
jne 0x20d1b
movslq -0x4(%rsp), %rcx
leaq 0x30ba936(%rip), %rax   # 0x30db640
imulq $0x140, %rcx, %rcx      # imm = 0x140
addq %rcx, %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
jmp 0x20d1d
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x20cd8
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: DumpWadinclude()
static void     DumpWadinclude()
{
    Log("Wadinclude list :\n");
    WadInclude_i it;
    for (it = g_WadInclude.begin(); it != g_WadInclude.end(); it++)
    {
        Log("[%s]\n", it->c_str());
    }
}

// Assembly:
subq $0x88, %rsp
leaq 0xca2f(%rip), %rdi      # 0x2fa9d
movb $0x0, %al
callq 0xb5d0
leaq 0x68(%rsp), %rdi
callq 0x25800
leaq 0x48(%rsp), %rdi
leaq 0x61b8705(%rip), %rsi   # 0x61db790
callq 0x25830
movq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x61b86c9(%rip), %rsi   # 0x61db790
callq 0x25890
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x25860
testb $0x1, %al
jne 0x230e1
jmp 0x23117
leaq 0x68(%rsp), %rdi
callq 0x258c0
movq %rax, %rdi
callq 0x41a0
movq %rax, %rsi
leaq 0xcd12(%rip), %rdi      # 0x2fe0f
movb $0x0, %al
callq 0xb5d0
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
callq 0x258d0
jmp 0x230bb
addq $0x88, %rsp
retq
nop
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: BoundWorld()
static void     BoundWorld()
{
    int             i;
    brushhull_t*    h;

    world_bounds.reset();

    for (i = 0; i < g_nummapbrushes; i++)
    {
        h = &g_mapbrushes[i].hulls[0];
        if (!h->faces)
        {
            continue;
        }
        world_bounds.add(h->bounds);
    }

    Verbose("World bounds: (%i %i %i) to (%i %i %i)\n",
            (int)world_bounds.m_Mins[0], (int)world_bounds.m_Mins[1], (int)world_bounds.m_Mins[2],
            (int)world_bounds.m_Maxs[0], (int)world_bounds.m_Maxs[1], (int)world_bounds.m_Maxs[2]);
}

// Assembly:
subq $0x18, %rsp
leaq 0x61b8265(%rip), %rdi   # 0x61db690
callq 0x12490
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
leaq 0x30b81ed(%rip), %rcx   # 0x30db630
cmpl (%rcx), %eax
jge 0x23492
movslq 0x14(%rsp), %rcx
leaq 0x30b81ed(%rip), %rax   # 0x30db640
imulq $0x140, %rcx, %rcx      # imm = 0x140
addq %rcx, %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x23474
jmp 0x23485
movq 0x8(%rsp), %rsi
leaq 0x61b8210(%rip), %rdi   # 0x61db690
callq 0x25a90
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x23438
cvttsd2si 0x61b81f6(%rip), %esi # 0x61db690
cvttsd2si 0x61b81f6(%rip), %edx # 0x61db698
cvttsd2si 0x61b81f6(%rip), %ecx # 0x61db6a0
cvttsd2si 0x61b81f5(%rip), %r8d # 0x61db6a8
cvttsd2si 0x61b81f4(%rip), %r9d # 0x61db6b0
cvttsd2si 0x61b81f4(%rip), %eax # 0x61db6b8
leaq 0xc6c7(%rip), %rdi      # 0x2fb92
movl %eax, (%rsp)
movb $0x0, %al
callq 0xc000
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: EmitPlanes()
static void     EmitPlanes()
{
    int             i;
    dplane_t*       dp;
    plane_t*        mp;

    g_numplanes = g_nummapplanes;
    mp = g_mapplanes;
    dp = g_dplanes;
#ifdef HLCSG_HLBSP_DOUBLEPLANE
	{
		char name[_MAX_PATH];
		safe_snprintf (name, _MAX_PATH, "%s.pln", g_Mapname);
		FILE *planeout = fopen (name, "wb");
		if (!planeout)
			Error("Couldn't open %s", name);
		SafeWrite (planeout, g_mapplanes, g_nummapplanes * sizeof (plane_t));
		fclose (planeout);
	}
#endif
    for (i = 0; i < g_nummapplanes; i++, mp++, dp++)
    {
        //if (!(mp->redundant))
        //{
        //    Log("EmitPlanes: plane %i non redundant\n", i);
            VectorCopy(mp->normal, dp->normal);
            dp->dist = mp->dist;
            dp->type = mp->type;
       // }
        //else
       // {
       //     Log("EmitPlanes: plane %i redundant\n", i);
       // }
    }
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
leaq 0x30b6e02(%rip), %rax   # 0x30da9a0
movl (%rax), %ecx
leaq 0xafb8bd(%rip), %rax    # 0xb1f464
movl %ecx, (%rax)
leaq 0x20b6df0(%rip), %rax   # 0x20da9a0
movq %rax, 0x1010(%rsp)
leaq 0xafb8b1(%rip), %rax    # 0xb1f470
movq %rax, 0x1018(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
leaq 0x7f21(%rip), %rdx      # 0x2baf9
leaq 0x12801(%rip), %rcx     # 0x363e0
movb $0x0, %al
callq 0x99e0
leaq 0x10(%rsp), %rdi
leaq 0x7d24(%rip), %rsi      # 0x2b916
callq 0x4460
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x23c17
leaq 0x10(%rsp), %rsi
leaq 0xb16c(%rip), %rdi      # 0x2ed7c
movb $0x0, %al
callq 0xba80
movq 0x8(%rsp), %rdi
leaq 0x30b6d7d(%rip), %rax   # 0x30da9a0
movslq (%rax), %rax
shlq $0x6, %rax
movl %eax, %edx
leaq 0x20b6d6d(%rip), %rsi   # 0x20da9a0
callq 0xb130
movq 0x8(%rsp), %rdi
callq 0x43a0
movl $0x0, 0x1024(%rsp)
movl 0x1024(%rsp), %eax
leaq 0x30b6d45(%rip), %rcx   # 0x30da9a0
cmpl (%rcx), %eax
jge 0x23d2d
movq 0x1010(%rsp), %rax
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x1018(%rsp), %rax
movss %xmm0, (%rax)
movq 0x1010(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x1018(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0x1010(%rsp), %rax
movsd 0x10(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x1018(%rsp), %rax
movss %xmm0, 0x8(%rax)
movq 0x1010(%rsp), %rax
movsd 0x30(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x1018(%rsp), %rax
movss %xmm0, 0xc(%rax)
movq 0x1010(%rsp), %rax
movl 0x38(%rax), %ecx
movq 0x1018(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x1024(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1024(%rsp)
movq 0x1010(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x1010(%rsp)
movq 0x1018(%rsp), %rax
addq $0x14, %rax
movq %rax, 0x1018(%rsp)
jmp 0x23c4d
addq $0x1028, %rsp           # imm = 0x1028
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: MarkEntForNoclip(entity_t*)
static void     MarkEntForNoclip(entity_t*  ent)
{
    int             i;
    brush_t*        b;

    for (i = ent->firstbrush; i < ent->firstbrush + ent->numbrushes; i++)
    {
        b = &g_mapbrushes[i];
        b->noclip = 1;  

        BrushClipHullsDiscarded++;
        ClipNodesDiscarded += b->numsides;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movl 0x18(%rcx), %ecx
movq -0x8(%rsp), %rdx
addl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x23dc0
movslq -0xc(%rsp), %rcx
leaq 0x30b78cb(%rip), %rax   # 0x30db640
imulq $0x140, %rcx, %rcx      # imm = 0x140
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl $0x1, 0x18(%rax)
movl 0x61b79da(%rip), %eax   # 0x61db770
addl $0x1, %eax
movl %eax, 0x61b79d1(%rip)   # 0x61db770
movq -0x18(%rsp), %rax
movl 0x14(%rax), %eax
addl 0x61b79c7(%rip), %eax   # 0x61db774
movl %eax, 0x61b79c1(%rip)   # 0x61db774
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x23d51
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: CopyFacesToOutside(brushhull_t*)
static bface_t* CopyFacesToOutside(brushhull_t* bh)
{
    bface_t*        f;
    bface_t*        newf;
    bface_t*        outside;

    outside = NULL;

    for (f = bh->faces; f; f = f->next)
    {
        newf = CopyFace(f);
        newf->w->getBounds(newf->bounds);
        newf->next = outside;
        outside = newf;
    }

    return outside;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x24cf4
movq 0x18(%rsp), %rdi
callq 0x20330
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
callq 0xe550
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x24ca0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: FreeSlave[P]vhlt/common/boundingbox.h
// Function: BoundingBox::testDisjoint(BoundingBox const&) const
bool testDisjoint(const BoundingBox& other) const
    {
#ifdef ZHLT_BOUNDINGBOX_PRECISION_FIX
        if ((m_Mins[0] > other.m_Maxs[0] + ON_EPSILON) ||
            (m_Mins[1] > other.m_Maxs[1] + ON_EPSILON) ||
            (m_Mins[2] > other.m_Maxs[2] + ON_EPSILON) ||
            (m_Maxs[0] < other.m_Mins[0] - ON_EPSILON) ||
            (m_Maxs[1] < other.m_Mins[1] - ON_EPSILON) ||
            (m_Maxs[2] < other.m_Mins[2] - ON_EPSILON))
#else
        if ((m_Mins[0] > other.m_Maxs[0]) ||
            (m_Mins[1] > other.m_Maxs[1]) ||
            (m_Mins[2] > other.m_Maxs[2]) ||
            (m_Maxs[0] < other.m_Mins[0]) ||
            (m_Maxs[1] < other.m_Mins[1]) ||
            (m_Maxs[2] < other.m_Mins[2]))
#endif
        {
            return true;
        }
        return false;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x7b63(%rip), %xmm1     # 0x2d658
addsd 0x18(%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x25bbd
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x7b3d(%rip), %xmm1     # 0x2d658
addsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x25bbd
movq -0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x7b17(%rip), %xmm1     # 0x2d658
addsd 0x28(%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x25bbd
movq -0x20(%rsp), %rax
movsd 0x18(%rax), %xmm1
movq -0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x7af1(%rip), %xmm2     # 0x2d658
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
ja 0x25bbd
movq -0x20(%rsp), %rax
movsd 0x20(%rax), %xmm1
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x7acb(%rip), %xmm2     # 0x2d658
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
ja 0x25bbd
movq -0x20(%rsp), %rax
movsd 0x28(%rax), %xmm1
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x7aa5(%rip), %xmm2     # 0x2d658
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x25bc4
movb $0x1, -0x1(%rsp)
jmp 0x25bc9
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: CleanupName(char const*, char*)
static void     CleanupName(const char* const in, char* out)
{
    int             i;

    for (i = 0; i < MAXWADNAME; i++)
    {
        if (!in[i])
        {
            break;
        }

        out[i] = toupper(in[i]);
    }

    for (; i < MAXWADNAME; i++)
    {
        out[i] = 0;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0x26fee
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x26fbf
jmp 0x26fee
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x46f0
movb %al, %dl
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x26fa6
jmp 0x26ff0
cmpl $0x10, 0x4(%rsp)
jge 0x27012
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x26ff0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: AddAnimatingTextures()
void            AddAnimatingTextures()
{
    int             base;
    int             i, j, k;
    char            name[MAXWADNAME];

    base = nummiptex;

    for (i = 0; i < base; i++)
    {
        if ((miptex[i].name[0] != '+') && (miptex[i].name[0] != '-'))
        {
            continue;
        }

        safe_strncpy(name, miptex[i].name, MAXWADNAME);

        for (j = 0; j < 20; j++)
        {
            if (j < 10)
            {
                name[1] = '0' + j;
            }
            else
            {
                name[1] = 'A' + j - 10;                    // alternate animation
            }

            // see if this name exists in the wadfile
            for (k = 0; k < nTexLumps; k++)
            {
                if (!strcmp(name, lumpinfo[k].name))
                {
                    FindMiptex(name);                      // add to the miptex list
                    break;
                }
            }
        }
    }

    if (nummiptex - base)
    {
        Log("added %i additional animating textures.\n", nummiptex - base);
    }
}

// Assembly:
subq $0x28, %rsp
movl 0x61b4a42(%rip), %eax   # 0x61dbffc
movl %eax, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x276df
movslq 0x20(%rsp), %rcx
leaq 0x61b4a20(%rip), %rax   # 0x61dc000
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movsbl 0x10(%rax), %eax
cmpl $0x2b, %eax
je 0x27611
movslq 0x20(%rsp), %rcx
leaq 0x61b4a04(%rip), %rax   # 0x61dc000
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movsbl 0x10(%rax), %eax
cmpl $0x2d, %eax
je 0x27611
jmp 0x276cf
movq %rsp, %rdi
movslq 0x20(%rsp), %rax
leaq 0x61b49e0(%rip), %rsi   # 0x61dc000
imulq $0x24, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
movl $0x10, %edx
callq 0x9af0
movl $0x0, 0x1c(%rsp)
cmpl $0x14, 0x1c(%rsp)
jge 0x276cd
cmpl $0xa, 0x1c(%rsp)
jge 0x2765c
movl 0x1c(%rsp), %eax
addl $0x30, %eax
movb %al, 0x1(%rsp)
jmp 0x2766a
movl 0x1c(%rsp), %eax
addl $0x41, %eax
subl $0xa, %eax
movb %al, 0x1(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x61b497c(%rip), %eax   # 0x61dbff8
jge 0x276bb
movq %rsp, %rdi
movq 0x61b4968(%rip), %rsi   # 0x61dbff0
movslq 0x18(%rsp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
callq 0x4530
cmpl $0x0, %eax
jne 0x276ac
movq %rsp, %rdi
callq 0x27710
jmp 0x276bb
jmp 0x276ae
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x27672
jmp 0x276bd
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2763d
jmp 0x276cf
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x275c6
movl 0x61b4917(%rip), %eax   # 0x61dbffc
subl 0x24(%rsp), %eax
cmpl $0x0, %eax
je 0x27706
movl 0x61b4908(%rip), %esi   # 0x61dbffc
subl 0x24(%rsp), %esi
leaq 0x87f1(%rip), %rdi      # 0x2fef0
movb $0x0, %al
callq 0xb5d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: FindMiptex(char const*)
static int      FindMiptex(const char* const name)
{
    int             i;
#ifdef HLCSG_TEXMAP64_FIX
	if (strlen (name) >= MAXWADNAME)
	{
		Error ("Texture name is too long (%s)\n", name);
	}
#endif

    ThreadLock();
    for (i = 0; i < nummiptex; i++)
    {
        if (!strcmp(name, miptex[i].name))
        {
            ThreadUnlock();
            return i;
        }
    }

    hlassume(nummiptex < MAX_MAP_TEXTURES, assume_MAX_MAP_TEXTURES);
    safe_strncpy(miptex[i].name, name, MAXWADNAME);
    nummiptex++;
    ThreadUnlock();
    return i;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x41c0
cmpq $0x10, %rax
jb 0x2773c
movq 0x8(%rsp), %rsi
leaq 0x893a(%rip), %rdi      # 0x3006f
movb $0x0, %al
callq 0xba80
callq 0xd720
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x61b48a9(%rip), %eax   # 0x61dbffc
jge 0x27799
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rax
leaq 0x61b489a(%rip), %rsi   # 0x61dc000
imulq $0x24, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
callq 0x4530
cmpl $0x0, %eax
jne 0x2778a
callq 0xd740
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x277f8
jmp 0x2778c
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x27749
cmpl $0x1000, 0x61b4859(%rip) # imm = 0x1000
setl %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x24, %esi
callq 0xc400
movslq 0x4(%rsp), %rax
leaq 0x61b483e(%rip), %rdi   # 0x61dc000
imulq $0x24, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x9af0
movl 0x61b481a(%rip), %eax   # 0x61dbffc
addl $0x1, %eax
movl %eax, 0x61b4811(%rip)   # 0x61dbffc
callq 0xd740
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: lump_sorter_by_wad_and_name(void const*, void const*)
static int CDECL lump_sorter_by_wad_and_name(const void* lump1, const void* lump2)
{
    lumpinfo_t*     plump1 = (lumpinfo_t*)lump1;
    lumpinfo_t*     plump2 = (lumpinfo_t*)lump2;

    if (plump1->iTexFile == plump2->iTexFile)
    {
        return strcmp(plump1->name, plump2->name);
    }
    else
    {
        return plump1->iTexFile - plump2->iTexFile;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movq (%rsp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x2826e
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq (%rsp), %rsi
addq $0x10, %rsi
callq 0x4530
movl %eax, 0x24(%rsp)
jmp 0x28281
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movq (%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: texmap_clear()
static void texmap_clear ()
{
	int i;
	ThreadLock ();
	for (i = 0; i < numtexmap; i++)
	{
		free (texmap[i]);
	}
	numtexmap = 0;
	ThreadUnlock ();
}

// Assembly:
pushq %rax
callq 0xd720
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x61d7d08(%rip), %eax   # 0x6200000
jge 0x2831c
movslq 0x4(%rsp), %rcx
leaq 0x61d7d0a(%rip), %rax   # 0x6200010
movq (%rax,%rcx,8), %rdi
callq 0x4470
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x282ee
movl $0x0, 0x61d7cda(%rip)   # 0x6200000
callq 0xd740
popq %rax
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: texmap_store(char*, bool)
static int texmap_store (char *texname, bool shouldlock = true)
	// This function should never be called unless a new entry in g_texinfo is being allocated.
{
	int i;
	if (shouldlock)
	{
		ThreadLock ();
	}
#ifdef HLCSG_HLBSP_REDUCETEXTURE
	hlassume (numtexmap < MAX_INTERNAL_MAP_TEXINFO, assume_MAX_MAP_TEXINFO); // This error should never appear.
#else
	hlassume (numtexmap < MAX_MAP_TEXINFO, assume_MAX_MAP_TEXINFO); // This error should never appear.
#endif
	i = numtexmap;
	texmap[numtexmap] = strdup (texname);
	numtexmap++;
	if (shouldlock)
	{
		ThreadUnlock ();
	}
	return i;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x28d8e
callq 0xd720
cmpl $0x40000, 0x61d7268(%rip) # imm = 0x40000
setl %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x26, %esi
callq 0xc400
movl 0x61d724f(%rip), %eax   # 0x6200000
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x46b0
movq %rax, %rdx
movslq 0x61d7237(%rip), %rcx   # 0x6200000
leaq 0x61d7240(%rip), %rax   # 0x6200010
movq %rdx, (%rax,%rcx,8)
movl 0x61d7226(%rip), %eax   # 0x6200000
addl $0x1, %eax
movl %eax, 0x61d721d(%rip)   # 0x6200000
testb $0x1, 0xf(%rsp)
je 0x28def
callq 0xd740
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/wadcfg.cpp
// Function: LoadWadcfgfile(char const*)
void LoadWadcfgfile (const char *filename)
{
	Log ("Loading wad configuration file '%s' :\n", filename);
	int count = 0;
	int size;
	char *buffer;
	size = LoadFile (filename, &buffer);
	ParseFromMemory (buffer, size);
	while (GetToken (true))
	{
		Log (" ");
		bool include = false;
		if (!strcasecmp (g_token, "include"))
		{
			Log ("include ");
			include = true;
			if (!GetToken (true))
			{
				Error ("parsing '%s': unexpected end of file.", filename);
			}
		}
		Log ("\"%s\"\n", g_token);
		if (g_iNumWadPaths >= MAX_WADPATHS)
		{
			Error ("parsing '%s': too many wad files.", filename);
		}
		count++;
#ifdef HLCSG_AUTOWAD_NEW
		PushWadPath (g_token, !include);
#else
		wadpath_t *current = (wadpath_t *)malloc (sizeof (wadpath_t));
		hlassume (current != NULL, assume_NoMemory);
		g_pWadPaths[g_iNumWadPaths] = current;
		g_iNumWadPaths++;
		safe_strncpy (current->path, g_token, _MAX_PATH);
		current->usedbymap = true; // what's this?
		current->usedtextures = 0;
		if (include)
		{
			Developer (DEVELOPER_LEVEL_MESSAGE, "LoadWadcfgfile: including '%s'.\n", current->path);
			g_WadInclude.push_back(current->path);
		}
#endif
	}
	free (buffer); // should not be freed because it is still being used as script buffer
	//Log ("Using custom wadfile configuration: '%s' (with %i wad%s)\n", filename, count, count > 1 ? "s" : "");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x68f3(%rip), %rdi      # 0x30198
movb $0x0, %al
callq 0xb5d0
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb180
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0xcc40
movl $0x1, %edi
callq 0xce10
testb $0x1, %al
jne 0x298e8
jmp 0x299a8
leaq 0xd6c(%rip), %rdi       # 0x2a65b
movb $0x0, %al
callq 0xb5d0
movb $0x0, 0xf(%rsp)
leaq 0x20a7bfe(%rip), %rdi   # 0x20d1500
leaq 0x3854(%rip), %rsi      # 0x2d15d
callq 0x4410
cmpl $0x0, %eax
jne 0x29949
leaq 0x67e1(%rip), %rdi      # 0x300fb
movb $0x0, %al
callq 0xb5d0
movb $0x1, 0xf(%rsp)
movl $0x1, %edi
callq 0xce10
testb $0x1, %al
jne 0x29947
movq 0x20(%rsp), %rsi
leaq 0x6795(%rip), %rdi      # 0x300d5
movb $0x0, %al
callq 0xba80
jmp 0x29949
leaq 0xd98(%rip), %rdi       # 0x2a6e8
leaq 0x20a7ba9(%rip), %rsi   # 0x20d1500
movb $0x0, %al
callq 0xb5d0
leaq 0x63d6aab(%rip), %rax   # 0x6400410
cmpl $0x80, (%rax)
jl 0x29980
movq 0x20(%rsp), %rsi
leaq 0x678b(%rip), %rdi      # 0x30104
movb $0x0, %al
callq 0xba80
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
movzbl %al, %esi
andl $0x1, %esi
leaq 0x20a7b62(%rip), %rdi   # 0x20d1500
callq 0x299c0
jmp 0x298d5
movq 0x10(%rsp), %rdi
callq 0x4470
addq $0x28, %rsp
retq
nop
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/wadpath.cpp
// Function: PushWadPath(char const*, bool)
void        PushWadPath(const char* const path, bool inuse)
{
    int         i;
    wadpath_t*  current;

#ifdef HLCSG_AUTOWAD_NEW
	hlassume (g_iNumWadPaths < MAX_WADPATHS, assume_MAX_TEXFILES);
#else
    if (!strlen(path))
        return; // no path

    // check for pre-existing path
    for (i = 0; i < g_iNumWadPaths; i++)
    {
        current = g_pWadPaths[i];

        if (!strcmp(current->path, path))
            return; 
    }
#endif

    current = (wadpath_t*)malloc(sizeof(wadpath_t));

    safe_strncpy(current->path, path, _MAX_PATH);
    current->usedbymap = inuse;
    current->usedtextures = 0;  // should be updated later in autowad procedures
#ifdef HLCSG_AUTOWAD_NEW
	current->totaltextures = 0;
#endif

    g_pWadPaths[g_iNumWadPaths++] = current;

#ifdef _DEBUG
    Log("[dbg] PushWadPath: %i[%s]\n", g_iNumWadPaths, path);
#endif
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpl $0x80, 0x63d6a34(%rip)  # 0x6400410
setl %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x10, %esi
callq 0xc400
movl $0x100c, %edi           # imm = 0x100C
callq 0x4500
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x9af0
movb 0xf(%rsp), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0x1000(%rax)
movq (%rsp), %rax
movl $0x0, 0x1004(%rax)
movq (%rsp), %rax
movl $0x0, 0x1008(%rax)
movq (%rsp), %rdx
movl 0x63d69c9(%rip), %eax   # 0x6400410
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x63d69be(%rip)   # 0x6400410
movslq %eax, %rcx
leaq 0x63d65b4(%rip), %rax   # 0x6400010
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlcsg/wadpath.cpp
// Function: FreeWadPaths()
void        FreeWadPaths()
{
    int         i;
    wadpath_t*  current;

    for (i = 0; i < g_iNumWadPaths; i++)
    {
        current = g_pWadPaths[i];
        free(current);
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x63d698a(%rip), %eax   # 0x6400410
jge 0x29ab4
movslq 0x14(%rsp), %rcx
leaq 0x63d657c(%rip), %rax   # 0x6400010
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4470
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x29a7c
addq $0x18, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlcsg/wadpath.cpp
// Function: GetUsedWads()
void        GetUsedWads()
{
    const char* pszWadPaths;
    char        szTmp[_MAX_PATH];
    int         i, j;

    pszWadPaths = ValueForKey(&g_entities[0], "wad");

#ifdef HLCSG_AUTOWAD_NEW
	for (i = 0; ; )
	{
		for (j = i; pszWadPaths[j] != '\0'; j++)
		{
			if (pszWadPaths[j] == ';')
			{
				break;
			}
		}
		if (j - i > 0)
		{
			int count = qmin (j - i, _MAX_PATH - 1);
			memcpy (szTmp, &pszWadPaths[i], count);
			szTmp[count] = '\0';

			if (g_iNumWadPaths >= MAX_WADPATHS)
			{
				Error ("Too many wad files");
			}
			PushWadPath (szTmp, true);
		}
		if (pszWadPaths[j] == '\0')
		{
			break;
		}
		else
		{
			i = j + 1;
		}
	}
#else
    for(i = 0; i < MAX_WADPATHS; i++)
    {
        memset(szTmp, 0, sizeof(szTmp));    // are you happy zipster?
        for (j = 0; j < _MAX_PATH; j++, pszWadPaths++)
        {
            if (pszWadPaths[0] == ';')
            {
                pszWadPaths++;
                PushWadPath(szTmp, true);
                break;
            }

            if (pszWadPaths[0] == 0)
            {
                PushWadPath(szTmp, true); // fix by AmericanRPG for last wadpath ignorance bug
                return;
            }

            szTmp[j] = pszWadPaths[0];
        }
    }
#endif
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
leaq 0x20039e2(%rip), %rdi   # 0x202d4b0
leaq 0x4f54(%rip), %rsi      # 0x2ea29
callq 0x7ff0
movq %rax, 0x1010(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x1010(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x29b2f
movq 0x1010(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x29b20
jmp 0x29b2f
jmp 0x29b22
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x29af2
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
cmpl $0x0, %eax
jle 0x29bbb
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
cmpl $0xfff, %eax            # imm = 0xFFF
jge 0x29b58
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
movl %eax, (%rsp)
jmp 0x29b62
movl $0xfff, %eax            # imm = 0xFFF
movl %eax, (%rsp)
jmp 0x29b62
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x1010(%rsp), %rsi
movslq 0xc(%rsp), %rax
addq %rax, %rsi
movslq 0x4(%rsp), %rdx
callq 0x4310
movslq 0x4(%rsp), %rax
movb $0x0, 0x10(%rsp,%rax)
cmpl $0x80, 0x63d6874(%rip)  # 0x6400410
jl 0x29bac
leaq 0x661a(%rip), %rdi      # 0x301bf
movb $0x0, %al
callq 0xba80
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x299c0
movq 0x1010(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x29bd3
jmp 0x29be3
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x29aea
addq $0x1018, %rsp           # imm = 0x1018
retq
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::getResultCapture()
IResultCapture& getResultCapture() {
        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
            return *capture;
        else
            throw std::logic_error( "No result capture instance" );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xf5b0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf54b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
leaq 0x6e399(%rip), %rsi     # 0x7d8ff
callq 0xe920
jmp 0xf56d
movq -0x20(%rbp), %rdi
movq 0xa5a50(%rip), %rsi     # 0xb4fc8
movq 0xa5a11(%rip), %rdx     # 0xb4f90
callq 0xeb10
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe4c0
movq -0x10(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::makeReporter(Catch::Ptr<Catch::Config> const&)
Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
        std::vector<std::string> reporters = config->getReporterNames();
        if( reporters.empty() )
            reporters.push_back( "console" );

        Ptr<IStreamingReporter> reporter;
        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
                it != itEnd;
                ++it )
            reporter = addReporter( reporter, createReporter( *it, config ) );
        return reporter;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18bb0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x18bd0
leaq -0x28(%rbp), %rdi
callq 0x18c10
testb $0x1, %al
jne 0xf878
jmp 0xf8f5
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xeb70
movq -0xa8(%rbp), %rdx
leaq 0x6e0a8(%rip), %rsi     # 0x7d93e
leaq -0x48(%rbp), %rdi
callq 0x18c80
jmp 0xf8a1
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x18c50
jmp 0xf8b0
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0x49(%rbp), %rdi
callq 0xe710
jmp 0xf8f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xf8e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xecd8
leaq -0x49(%rbp), %rdi
callq 0xe710
jmp 0xfa51
movq -0xa0(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
callq 0x18d30
jmp 0xf907
leaq -0x28(%rbp), %rdi
callq 0x18d50
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x18d80
leaq -0x28(%rbp), %rdi
callq 0x18dc0
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x18d80
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x18df0
testb $0x1, %al
jne 0xf951
jmp 0xfa16
leaq -0x68(%rbp), %rdi
callq 0x18e30
movq %rax, %rsi
movq -0x10(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0xf5c0
jmp 0xf96f
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xfa70
jmp 0xf98b
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x18e50
jmp 0xf9a0
leaq -0x88(%rbp), %rdi
callq 0x18b70
leaq -0x90(%rbp), %rdi
callq 0x18b70
leaq -0x68(%rbp), %rdi
callq 0x18ec0
jmp 0xf93b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfa51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfa45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfa08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x18b70
leaq -0x90(%rbp), %rdi
callq 0x18b70
jmp 0xfa45
movb $0x1, -0x5d(%rbp)
testb $0x1, -0x5d(%rbp)
jne 0xfa2c
movq -0xa0(%rbp), %rdi
callq 0x18b70
leaq -0x28(%rbp), %rdi
callq 0x18ee0
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x18b70
leaq -0x28(%rbp), %rdi
callq 0x18ee0
movq -0x58(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::addReporter(Catch::Ptr<Catch::IStreamingReporter> const&, Catch::Ptr<Catch::IStreamingReporter> const&)
Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
    Ptr<IStreamingReporter> resultingReporter;

    if( existingReporter ) {
        MultipleReporters* multi = dynamic_cast<MultipleReporters*>( existingReporter.get() );
        if( !multi ) {
            multi = new MultipleReporters;
            resultingReporter = Ptr<IStreamingReporter>( multi );
            if( existingReporter )
                multi->add( existingReporter );
        }
        else
            resultingReporter = existingReporter;
        multi->add( additionalReporter );
    }
    else
        resultingReporter = additionalReporter;

    return resultingReporter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x18d30
movq -0x10(%rbp), %rdi
callq 0x1c750
movq %rax, -0x48(%rbp)
jmp 0xfaaa
movq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0xfbe9
movq -0x10(%rbp), %rdi
callq 0x1c780
movq %rax, -0x60(%rbp)
jmp 0xfac7
movq -0x60(%rbp), %rax
cmpq $0x0, %rax
je 0xfb03
movq -0x60(%rbp), %rdi
leaq 0xa3e94(%rip), %rsi     # 0xb3970
leaq 0xa40c5(%rip), %rdx     # 0xb3ba8
xorl %eax, %eax
movl %eax, %ecx
callq 0xe780
movq %rax, -0x68(%rbp)
jmp 0xfb0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xfc1a
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0xfb0b
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xfbc7
movl $0x28, %edi
callq 0xe680
movq %rax, -0x70(%rbp)
jmp 0xfb2e
movq -0x70(%rbp), %rdi
callq 0x1c7a0
jmp 0xfb39
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x18ad0
jmp 0xfb50
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x18e50
jmp 0xfb5f
leaq -0x40(%rbp), %rdi
callq 0x18b70
movq -0x10(%rbp), %rdi
callq 0x1c750
movq %rax, -0x78(%rbp)
jmp 0xfb77
movq -0x78(%rbp), %rax
cmpq $0x0, %rax
je 0xfbc5
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c7e0
jmp 0xfb90
jmp 0xfbc5
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0xe6a0
jmp 0xfc1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18b70
jmp 0xfc1a
jmp 0xfbd8
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18e50
jmp 0xfbd6
jmp 0xfbd8
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c7e0
jmp 0xfbe7
jmp 0xfbfa
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18e50
jmp 0xfbf8
jmp 0xfbfa
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xfc0d
movq -0x58(%rbp), %rdi
callq 0x18b70
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x18b70
movq -0x28(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::addListeners(Catch::Ptr<Catch::IConfig const> const&, Catch::Ptr<Catch::IStreamingReporter>)
Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
        IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
        for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
                it != itEnd;
                ++it )
            reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
        return reporters;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0xf820
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x18f40
leaq -0x30(%rbp), %rdi
callq 0x19030
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x19060
leaq -0x30(%rbp), %rdi
callq 0x190a0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x19060
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x190d0
testb $0x1, %al
jne 0xfccc
jmp 0xfdc8
leaq -0x38(%rbp), %rdi
callq 0x19110
movq %rax, %rdi
callq 0x19130
movq %rax, -0xa0(%rbp)
jmp 0xfce6
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x19150
jmp 0xfcf5
movq -0xa0(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x80(%rbp), %rsi
callq *%rax
movq %rax, -0xa8(%rbp)
jmp 0xfd12
movq -0xa8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x18ad0
jmp 0xfd24
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xfa70
jmp 0xfd3a
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x18e50
jmp 0xfd4c
leaq -0x58(%rbp), %rdi
callq 0x18b70
leaq -0x60(%rbp), %rdi
callq 0x18b70
leaq -0x80(%rbp), %rdi
callq 0x191a0
leaq -0x38(%rbp), %rdi
callq 0x191c0
jmp 0xfcb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xfdf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xfdbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xfdb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x18b70
leaq -0x60(%rbp), %rdi
callq 0x18b70
leaq -0x80(%rbp), %rdi
callq 0x191a0
jmp 0xfdf6
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x191e0
jmp 0xfddd
leaq -0x30(%rbp), %rdi
callq 0x19220
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x19220
movq -0x68(%rbp), %rdi
callq 0xeb60
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::setTags(Catch::TestCaseInfo&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags )
    {
        testCaseInfo.tags = tags;
        testCaseInfo.lcaseTags.clear();

        std::ostringstream oss;
        for( std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) {
            oss << "[" << *it << "]";
            std::string lcaseTag = toLower( *it );
            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
            testCaseInfo.lcaseTags.insert( lcaseTag );
        }
        testCaseInfo.tagsAsString = oss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x1b1f0
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
callq 0x1b220
leaq -0x188(%rbp), %rdi
callq 0xe8d0
movq -0x10(%rbp), %rdi
callq 0x1b240
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b270
movq %rax, -0x198(%rbp)
leaq -0x190(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1b2a0
testb $0x1, %al
jne 0x106dc
jmp 0x1081b
leaq 0x6d654(%rip), %rsi     # 0x7dd37
leaq -0x188(%rbp), %rdi
callq 0xe670
movq %rax, -0x200(%rbp)
jmp 0x106f8
leaq -0x190(%rbp), %rdi
callq 0x1b2d0
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0xe5a0
movq %rax, -0x208(%rbp)
jmp 0x1071c
movq -0x208(%rbp), %rdi
leaq 0x6de01(%rip), %rsi     # 0x7e52b
callq 0xe670
jmp 0x10731
leaq -0x190(%rbp), %rdi
callq 0x1b2d0
movq %rax, %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x124a0
jmp 0x1074e
movq -0x8(%rbp), %rax
movl 0x108(%rax), %eax
movl %eax, -0x210(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x1ae90
movl %eax, -0x20c(%rbp)
jmp 0x10772
movl -0x20c(%rbp), %eax
movl -0x210(%rbp), %ecx
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x1b120
movb %dl, -0x219(%rbp)
movq %rax, -0x218(%rbp)
jmp 0x107b0
movb -0x219(%rbp), %al
movq -0x218(%rbp), %rcx
movq %rcx, -0x1d8(%rbp)
movb %al, -0x1d0(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xecd8
leaq -0x190(%rbp), %rdi
callq 0x1b2f0
jmp 0x106c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x10868
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xecd8
jmp 0x10868
leaq -0x1f8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xe6b0
jmp 0x10830
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xe800
leaq -0x1f8(%rbp), %rdi
callq 0xecd8
leaq -0x188(%rbp), %rdi
callq 0xe130
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xe130
movq -0x1a0(%rbp), %rdi
callq 0xeb60
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::filterTests(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&, Catch::TestSpec const&, Catch::IConfig const&)
std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
        std::vector<TestCase> filtered;
        filtered.reserve( testCases.size() );
        for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
                it != itEnd;
                ++it )
            if( matchTest( *it, testSpec, config ) )
                filtered.push_back( *it );
        return filtered;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x1a410
movq -0x10(%rbp), %rdi
callq 0x1a0a0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x1a430
jmp 0x10bd3
movq -0x10(%rbp), %rdi
callq 0x198d0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19900
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x19930
testb $0x1, %al
jne 0x10c00
jmp 0x10c64
leaq -0x40(%rbp), %rdi
callq 0x199c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x103b0
movb %al, -0x59(%rbp)
jmp 0x10c1e
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x10c27
jmp 0x10c57
leaq -0x40(%rbp), %rdi
callq 0x199c0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x1a560
jmp 0x10c3e
jmp 0x10c57
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1a5d0
jmp 0x10c81
jmp 0x10c59
leaq -0x40(%rbp), %rdi
callq 0x19dd0
jmp 0x10bed
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x10c77
movq -0x50(%rbp), %rdi
callq 0x1a5d0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xeb60
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::registerTestCase(Catch::ITestCase*, char const*, Catch::NameAndDesc const&, Catch::SourceLineInfo const&)
void registerTestCase
        (   ITestCase* testCase,
            char const* classOrQualifiedMethodName,
            NameAndDesc const& nameAndDesc,
            SourceLineInfo const& lineInfo ) {

        getMutableRegistryHub().registerTest
            ( makeTestCase
                (   testCase,
                    extractClassName( classOrQualifiedMethodName ),
                    nameAndDesc.name,
                    nameAndDesc.description,
                    lineInfo ) );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x10f30
movq %rax, -0x200(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x179(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0xeb70
movq -0x1f0(%rbp), %rsi
movq -0x1e8(%rbp), %rdx
leaq -0x178(%rbp), %rdi
callq 0x18c80
jmp 0x10cfc
leaq -0x158(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x1a630
jmp 0x10d11
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x210(%rbp)
leaq -0x1b1(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0xeb70
movq -0x210(%rbp), %rsi
movq -0x208(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x18c80
jmp 0x10d4e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x220(%rbp)
leaq -0x1d9(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0xeb70
movq -0x220(%rbp), %rsi
movq -0x218(%rbp), %rdx
leaq -0x1d8(%rbp), %rdi
callq 0x18c80
jmp 0x10d8c
movq -0x1f8(%rbp), %rsi
movq -0x20(%rbp), %r9
leaq -0x138(%rbp), %rdi
leaq -0x158(%rbp), %rdx
leaq -0x1b0(%rbp), %rcx
leaq -0x1d8(%rbp), %r8
callq 0x10f50
jmp 0x10dba
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x138(%rbp), %rsi
callq *%rax
jmp 0x10dd3
leaq -0x138(%rbp), %rdi
callq 0x1a7e0
leaq -0x1d8(%rbp), %rdi
callq 0xecd8
leaq -0x1d9(%rbp), %rdi
callq 0xe710
leaq -0x1b0(%rbp), %rdi
callq 0xecd8
leaq -0x1b1(%rbp), %rdi
callq 0xe710
leaq -0x158(%rbp), %rdi
callq 0xecd8
leaq -0x178(%rbp), %rdi
callq 0xecd8
leaq -0x179(%rbp), %rdi
callq 0xe710
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x10f0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x10f00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x10ee8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x10ed0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x10ec4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x1a7e0
leaq -0x1d8(%rbp), %rdi
callq 0xecd8
leaq -0x1d9(%rbp), %rdi
callq 0xe710
leaq -0x1b0(%rbp), %rdi
callq 0xecd8
leaq -0x1b1(%rbp), %rdi
callq 0xe710
leaq -0x158(%rbp), %rdi
callq 0xecd8
leaq -0x178(%rbp), %rdi
callq 0xecd8
leaq -0x179(%rbp), %rdi
callq 0xe710
movq -0x188(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::(anonymous namespace)::getTheRegistryHub()
inline RegistryHub*& getTheRegistryHub() {
            static RegistryHub* theRegistryHub = CATCH_NULL;
            if( !theRegistryHub )
                theRegistryHub = new RegistryHub();
            return theRegistryHub;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0xa4330(%rip)     # 0xb5810
jne 0x11526
movl $0xd0, %edi
callq 0xe680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x18460
jmp 0x114fd
movq -0x18(%rbp), %rax
movq %rax, 0xa4308(%rip)     # 0xb5810
jmp 0x11526
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0xd0, %esi
callq 0xe6a0
jmp 0x11533
leaq 0xa42e3(%rip), %rax     # 0xb5810
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0xeb60
nopl (%rax)