LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/map.cpp
// Function: CountEngineEntities()
unsigned int    CountEngineEntities()
{
    unsigned int x;
    unsigned num_engine_entities = 0;
    entity_t*       mapent = g_entities;

    // for each entity in the map
    for (x=0; x<g_numentities; x++, mapent++)
    {
        const char* classname = ValueForKey(mapent, "classname");

        // if its a light_spot or light_env, dont include it as an engine entity!
        if (classname)
        {
            if (   !strncasecmp(classname, "light", 5) 
                || !strncasecmp(classname, "light_spot", 10) 
                || !strncasecmp(classname, "light_environment", 17)
               )
            {
                const char* style = ValueForKey(mapent, "style");
                const char* targetname = ValueForKey(mapent, "targetname");

                // lightspots and lightenviroments dont have a targetname or style
                if (!strlen(targetname) && !atoi(style))
                {
                    continue;
                }
            }
        }

        num_engine_entities++;
    }

    return num_engine_entities;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x200a503(%rip), %r13   # 0x201f454
cmpl $0x0, (%r13)
je 0x15011
leaq 0x200a4fd(%rip), %rbx   # 0x201f460
xorl %r15d, %r15d
leaq 0x769d(%rip), %r14      # 0x1c60a
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7599
testq %rax, %rax
je 0x14ffc
movq %rax, %r12
movl $0x5, %edx
movq %rax, %rdi
leaq 0x773d(%rip), %rsi      # 0x1c6ce
callq 0x4410
testl %eax, %eax
je 0x14fca
movl $0xa, %edx
movq %r12, %rdi
leaq 0x77ba(%rip), %rsi      # 0x1c763
callq 0x4410
testl %eax, %eax
je 0x14fca
movl $0x11, %edx
movq %r12, %rdi
leaq 0x76f3(%rip), %rsi      # 0x1c6b4
callq 0x4410
testl %eax, %eax
jne 0x14ffc
movq %rbx, %rdi
leaq 0xbd75(%rip), %rsi      # 0x20d49
callq 0x7599
movq %rax, %r12
movq %rbx, %rdi
leaq 0x7772(%rip), %rsi      # 0x1c758
callq 0x7599
cmpb $0x0, (%rax)
jne 0x14ffc
movq %r12, %rdi
callq 0x4500
testl %eax, %eax
je 0x14ffe
incl %ebp
incl %r15d
addq $0x28, %rbx
cmpl (%r13), %r15d
jb 0x14f6f
jmp 0x15013
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/properties.cpp
// Function: properties_initialize(char const*)
void properties_initialize(const char* filename)
{
    if (filename == NULL)
    { return; }

    if (q_exists(filename))
    { Log("Loading null entity list from '%s'\n", filename); }
    else
    {
		Error("Could not find null entity list file '%s'\n", filename);
        return;
    }

	ifstream file(filename,ios::in);
	if(!file)
	{ 
		file.close();
		return; 
	}


	//begin reading list of items
	char line[MAX_VAL]; //MAX_VALUE //vluzacn
	memset(line,0,sizeof(char)*4096);
	while(!file.eof())
	{
		string str;
		getline(file,str);
		{ //--vluzacn
			char *s = strdup (str.c_str ());
			int i;
			for (i = 0; s[i] != '\0'; i++)
			{
				if (s[i] == '\n' || s[i] == '\r')
				{
					s[i] = '\0';
				}
			}
			str.assign (s);
			free (s);
		}
		if(str.size() < 1)
		{ continue; }
		g_invisible_items.insert(str);
	}
	file.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
testq %rdi, %rdi
je 0x153aa
movq %rdi, %r14
callq 0x9ada
testb %al, %al
je 0x1528d
leaq 0xb3bf(%rip), %rdi      # 0x20610
movq %r14, %rsi
xorl %eax, %eax
callq 0x9fb2
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x45d0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x152af
leaq 0x20(%rsp), %rdi
callq 0x40d0
jmp 0x153a0
leaq 0xb3a0(%rip), %rdi      # 0x20634
movq %r14, %rsi
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa2a0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
testb $0x2, 0x40(%rsp,%rcx)
jne 0x15396
addq $-0x18, %rax
leaq 0x10(%rsp), %rbp
movq %rsp, %r14
leaq 0x61b832a(%rip), %r15   # 0x61cd600
movq %rbp, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42e0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45f0
movq (%rsp), %rdi
callq 0x45c0
movq %rax, %r12
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x15325
cmpl $0xd, %ecx
je 0x15325
testl %ecx, %ecx
jne 0x15328
jmp 0x1532d
movb $0x0, (%rax)
incq %rax
jmp 0x15312
movq 0x8(%rsp), %r13
movq %r12, %rdi
callq 0x4180
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x44f0
movq %r12, %rdi
callq 0x43a0
cmpq $0x0, 0x8(%rsp)
je 0x15368
movq %r15, %rdi
movq %r14, %rsi
callq 0x1546e
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x1537e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4320
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
addq $-0x18, %rax
testb $0x2, 0x40(%rsp,%rcx)
je 0x152d6
leaq 0x20(%rsp), %rdi
callq 0x40d0
leaq 0x20(%rsp), %rdi
callq 0x4100
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x153be
movq %rax, %rbx
jmp 0x153de
jmp 0x153c5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x153de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4320
leaq 0x20(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4570
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: NewFaceFromFace(bface_s const*)
bface_t*        NewFaceFromFace(const bface_t* const in)
{
    bface_t*        newf;

    newf = (bface_t*)Alloc(sizeof(bface_t));

    newf->contents = in->contents;
    newf->texinfo = in->texinfo;
    newf->planenum = in->planenum;
    newf->plane = in->plane;
#ifdef HLCSG_EMPTYBRUSH
	newf->backcontents = in->backcontents;
#endif

    return newf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x68, %edi
callq 0x4994
movl 0x28(%rbx), %ecx
movl %ecx, 0x28(%rax)
movl 0x20(%rbx), %ecx
movl %ecx, 0x20(%rax)
movl 0x8(%rbx), %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movl 0x2c(%rbx), %ecx
movl %ecx, 0x2c(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: WriteDetailBrush(int, bface_s const*)
void WriteDetailBrush (int hull, const bface_t *faces)
{
	ThreadLock ();
	fprintf (out_detailbrush[hull], "0\n");
	for (const bface_t *f = faces; f; f = f->next)
	{
		Winding *w = f->w;
		fprintf (out_detailbrush[hull], "%i %u\n", f->planenum, w->m_NumPoints);
		for (int i = 0; i < w->m_NumPoints; i++)
		{
			fprintf (out_detailbrush[hull], "%5.8f %5.8f %5.8f\n", w->m_Points[i][0], w->m_Points[i][1], w->m_Points[i][2]);
		}
	}
	fprintf (out_detailbrush[hull], "-1 -1\n");
	ThreadUnlock ();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0xb695
movslq %ebp, %r12
leaq 0x61b792a(%rip), %r13   # 0x61cd6c0
movq (%r13,%r12,8), %rcx
leaq 0xab58(%rip), %rdi      # 0x208fa
movl $0x2, %esi
movl $0x1, %edx
callq 0x4630
testq %rbx, %rbx
je 0x15e2e
leaq 0xab17(%rip), %r15      # 0x208d4
movq 0x18(%rbx), %rbp
movq (%r13,%r12,8), %rdi
movq %rbx, (%rsp)
movl 0x8(%rbx), %edx
movl 0x8(%rbp), %ecx
leaq 0xaaf6(%rip), %rsi      # 0x208cd
xorl %eax, %eax
callq 0x4470
cmpl $0x0, 0x8(%rbp)
je 0x15e22
movl $0x10, %r14d
xorl %ebx, %ebx
movq (%r13,%r12,8), %rdi
movq 0x10(%rbp), %rax
movsd -0x10(%rax,%r14), %xmm0
movsd -0x8(%rax,%r14), %xmm1
movsd (%rax,%r14), %xmm2
movq %r15, %rsi
movb $0x3, %al
callq 0x4470
incq %rbx
movl 0x8(%rbp), %eax
addq $0x18, %r14
cmpq %rax, %rbx
jb 0x15dec
movq (%rsp), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x15dbd
movq (%r13,%r12,8), %rcx
leaq 0xbce5(%rip), %rdi      # 0x21b1f
movl $0x6, %esi
movl $0x1, %edx
callq 0x4630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb6a6
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: CopyFace(bface_s const*)
bface_t*        CopyFace(const bface_t* const f)
{
    bface_t*        n;

    n = NewFaceFromFace(f);
    n->w = f->w->Copy();
    n->bounds = f->bounds;
    return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x68, %edi
callq 0x4994
movq %rax, %r14
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r14)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movl 0x2c(%rbx), %eax
movl %eax, 0x2c(%r14)
movq 0x18(%rbx), %rdi
callq 0xc00c
movq %rax, 0x18(%r14)
movups 0x38(%rbx), %xmm0
movups 0x48(%rbx), %xmm1
movups 0x58(%rbx), %xmm2
movups %xmm0, 0x38(%r14)
movups %xmm1, 0x48(%r14)
movups %xmm2, 0x58(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: CopyFaceList(bface_s*)
bface_t*        CopyFaceList(bface_t* f)
{
    bface_t*        head;
    bface_t*        n;

    if (f)
    {
        head = CopyFace(f);
        n = head;
        f = f->next;

        while (f)
        {
            n->next = CopyFace(f);

            n = n->next;
            f = f->next;
        }

        return head;
    }
    else
    {
        return NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15eff
movq %rdi, %r14
callq 0x15e5c
movq %rax, %rbx
movq (%r14), %r14
testq %r14, %r14
je 0x15f01
movq %rbx, %r15
movq %r14, %rdi
callq 0x15e5c
movq %rax, (%r15)
movq (%r14), %r14
movq %rax, %r15
testq %r14, %r14
jne 0x15ee7
jmp 0x15f01
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: FreeFaceList(bface_s*)
void            FreeFaceList(bface_t* f)
{
    if (f)
    {
        if (f->next)
        {
            FreeFaceList(f->next);
        }
        FreeFace(f);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x15f38
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x15f20
callq 0x15f0a
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15f2f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x4999
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/qcsg.cpp
// Function: LoadWadValue()
void LoadWadValue ()
{
	char *wadvalue;
	ParseFromMemory (g_dentdata, g_entdatasize);
	epair_t *e;
	entity_t ent0;
	entity_t *mapent = &ent0;
	memset (mapent, 0, sizeof (entity_t));
	if (!GetToken (true))
	{
		wadvalue = strdup ("");
	}
	else
	{
		if (strcmp (g_token, "{"))
		{
			Error ("ParseEntity: { not found");
		}
		while (1)
		{
			if (!GetToken (true))
			{
				Error ("ParseEntity: EOF without closing brace");
			}
			if (!strcmp (g_token, "}"))
			{
				break;
			}
			e = ParseEpair ();
			e->next = mapent->epairs;
			mapent->epairs = e;
		}
		wadvalue = strdup (ValueForKey (mapent, "wad"));
		epair_t *next;
		for (e = mapent->epairs; e; e = next)
		{
			next = e->next;
			free (e->key);
			free (e->value);
			free (e);
		}
	}
	if (*wadvalue)
	{
		Log ("Wad files required to run the map: \"%s\"\n", wadvalue);
	}
	else
	{
		Log ("Wad files required to run the map: (None)\n");
	}
	SetKeyValue (&g_entities[0], "wad", wadvalue);
	free (wadvalue);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x81b3b0(%rip), %rax    # 0x8314d4
movl (%rax), %esi
leaq 0x81b3b3(%rip), %rdi    # 0x8314e0
callq 0xafb0
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x20(%rsp)
movl $0x1, %edi
callq 0xb0b8
testb %al, %al
je 0x161ab
leaq 0x20ad354(%rip), %r14   # 0x20c34b0
cmpw $0x7b, (%r14)
je 0x16171
leaq 0x643e(%rip), %rdi      # 0x1c5a8
xorl %eax, %eax
callq 0xa2a0
leaq 0x646b(%rip), %rbx      # 0x1c5e3
movl $0x1, %edi
callq 0xb0b8
testb %al, %al
jne 0x16190
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa2a0
cmpw $0x7d, (%r14)
je 0x161bc
callq 0x70f0
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, 0x20(%rsp)
jmp 0x16178
leaq 0x7b07(%rip), %rdi      # 0x1dcb9
callq 0x45c0
movq %rax, %rbx
jmp 0x16207
leaq 0xa79e(%rip), %rsi      # 0x20961
movq %rsp, %r14
movq %r14, %rdi
callq 0x7599
movq %rax, %rdi
callq 0x45c0
movq %rax, %rbx
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x16207
movq (%r14), %r15
movq 0x8(%r14), %rdi
callq 0x43a0
movq 0x10(%r14), %rdi
callq 0x43a0
movq %r14, %rdi
callq 0x43a0
movq %r15, %r14
testq %r15, %r15
jne 0x161e2
cmpb $0x0, (%rbx)
je 0x1621f
leaq 0x6225(%rip), %rdi      # 0x1c438
movq %rbx, %rsi
xorl %eax, %eax
callq 0x9fb2
jmp 0x1622d
leaq 0x6194(%rip), %rdi      # 0x1c3ba
xorl %eax, %eax
callq 0x9fb2
leaq 0x200922c(%rip), %rdi   # 0x201f460
leaq 0xa726(%rip), %rsi      # 0x20961
movq %rbx, %rdx
callq 0x75d4
movq %rbx, %rdi
callq 0x43a0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movsd 0x18(%rsi), %xmm0
addsd 0x610d(%rip), %xmm0     # 0x1f518
movsd (%rdi), %xmm1
movb $0x1, %al
ucomisd %xmm0, %xmm1
ja 0x19484
movsd 0x8(%rdi), %xmm0
movsd 0x20(%rsi), %xmm1
addsd 0x60ef(%rip), %xmm1     # 0x1f518
ucomisd %xmm1, %xmm0
ja 0x19484
movsd 0x10(%rdi), %xmm0
movsd 0x28(%rsi), %xmm1
addsd 0x60d7(%rip), %xmm1     # 0x1f518
ucomisd %xmm1, %xmm0
ja 0x19484
movsd (%rsi), %xmm0
addsd 0x7285(%rip), %xmm0     # 0x206d8
ucomisd 0x18(%rdi), %xmm0
ja 0x19484
movsd 0x8(%rsi), %xmm0
addsd 0x7271(%rip), %xmm0     # 0x206d8
ucomisd 0x20(%rdi), %xmm0
ja 0x19484
movsd 0x10(%rsi), %xmm0
addsd 0x725d(%rip), %xmm0     # 0x206d8
ucomisd 0x28(%rdi), %xmm0
ja 0x19484
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x61b3fea(%rip), %r15   # 0x61cdf6c
testq %r15, %r15
jle 0x1a02b
xorl %r12d, %r12d
movq %rsp, %rbx
leaq (%r12,%r12,8), %rax
leaq 0x61b3fd4(%rip), %rcx   # 0x61cdf70
movzbl 0x10(%rcx,%rax,4), %ecx
cmpl $0x2d, %ecx
je 0x19fab
cmpl $0x2b, %ecx
jne 0x1a01f
leaq 0x61b3fbe(%rip), %rcx   # 0x61cdf70
leaq (%rcx,%rax,4), %rsi
addq $0x10, %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x8c21
xorl %ebp, %ebp
cmpl $0x9, %ebp
ja 0x19fd8
movl %ebp, %eax
orb $0x30, %al
movb %al, 0x1(%rsp)
jmp 0x19fdf
leal 0x37(%rbp), %eax
movb %al, 0x1(%rsp)
movslq 0x61b3f82(%rip), %r13   # 0x61cdf68
testq %r13, %r13
jle 0x1a018
movq 0x61b3f6e(%rip), %r14   # 0x61cdf60
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4450
testl %eax, %eax
je 0x1a010
addq $0x24, %r14
decq %r13
jne 0x19ff6
jmp 0x1a018
movq %rbx, %rdi
callq 0x1a056
incl %ebp
cmpl $0x14, %ebp
jne 0x19fc9
incq %r12
cmpq %r15, %r12
jne 0x19f91
movl 0x61b3f3b(%rip), %esi   # 0x61cdf6c
cmpl %r15d, %esi
je 0x1a047
subl %r15d, %esi
leaq 0x7dda(%rip), %rdi      # 0x21e1a
xorl %eax, %eax
callq 0x9fb2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4180
cmpq $0x10, %rax
jb 0x1a07d
leaq 0x7f26(%rip), %rdi      # 0x21f99
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa2a0
callq 0xb695
movslq 0x61b3ee3(%rip), %r12   # 0x61cdf6c
testq %r12, %r12
jle 0x1a0b8
leaq 0x61b3eeb(%rip), %r15   # 0x61cdf80
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4450
testl %eax, %eax
je 0x1a0fb
incq %r14
addq $0x24, %r15
cmpq %r14, %r12
jne 0x1a098
movl %r12d, %r14d
jmp 0x1a0bb
xorl %r14d, %r14d
xorl %edi, %edi
cmpl $0x1000, %r12d          # imm = 0x1000
setl %dil
movl $0x24, %esi
callq 0xaa4d
movl %r14d, %eax
leaq (%rax,%rax,8), %rax
leaq 0x61b3e90(%rip), %rcx   # 0x61cdf70
leaq (%rcx,%rax,4), %rdi
addq $0x10, %rdi
movl $0x10, %edx
movq %rbx, %rsi
callq 0x8c21
incl 0x61b3e71(%rip)         # 0x61cdf6c
callq 0xb6a6
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/FreeSlave[P]vhlt/hlcsg/textures.cpp
// Function: GetTextureByNumber_CSG(int)
const char *GetTextureByNumber_CSG(int texturenumber)
{
	if (texturenumber == -1)
		return "";
#ifdef HLCSG_TEXMAP64_FIX
	return texmap_retrieve (g_texinfo[texturenumber].miptex);
#else
	return texmap64_retrieve (g_texinfo[texturenumber].miptex);
#endif
}

// Assembly:
cmpl $-0x1, %edi
je 0x1ae49
pushq %rbx
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
leaq 0x1176605(%rip), %rcx   # 0x1191420
movl 0x20(%rcx,%rax,8), %ebx
testl %ebx, %ebx
setns %al
cmpl %ebx, 0x61d7146(%rip)   # 0x61f1f70
setg %cl
andb %al, %cl
movzbl %cl, %edi
xorl %esi, %esi
callq 0xaa4d
movslq %ebx, %rax
leaq 0x61d713d(%rip), %rcx   # 0x61f1f80
movq (%rcx,%rax,8), %rax
popq %rbx
retq
leaq 0x2e69(%rip), %rax      # 0x1dcb9
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d70(%rip), %rdi      # 0x220c6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x9fb2
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9beb
movq (%r14), %rdi
movl %eax, %esi
callq 0xafb0
movl $0x1, %edi
callq 0xb0b8
testb %al, %al
je 0x1b43b
leaq 0x20a811f(%rip), %r15   # 0x20c34b0
leaq 0x3d45(%rip), %r12      # 0x1f0dd
leaq 0x13fd(%rip), %r13      # 0x1c79c
leaq 0x63d6fda(%rip), %r14   # 0x63f2380
leaq 0x1362(%rip), %rdi      # 0x1c70f
xorl %eax, %eax
callq 0x9fb2
movq %r15, %rdi
movq %r12, %rsi
callq 0x4340
movl %eax, %ebp
testl %eax, %eax
jne 0x1b3f2
leaq 0x6c5d(%rip), %rdi      # 0x22029
xorl %eax, %eax
callq 0x9fb2
movl $0x1, %edi
callq 0xb0b8
testb %al, %al
jne 0x1b3f2
leaq 0x6c19(%rip), %rdi      # 0x22001
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa2a0
movq %r13, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x9fb2
cmpl $0x80, (%r14)
jl 0x1b419
leaq 0x6c23(%rip), %rdi      # 0x22032
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa2a0
xorl %esi, %esi
testl %ebp, %ebp
setne %sil
movq %r15, %rdi
callq 0x1b454
movl $0x1, %edi
callq 0xb0b8
testb %al, %al
jne 0x1b3a6
movq (%rsp), %rdi
callq 0x43a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x63d6eb1(%rip)   # 0x63f2380
jle 0x1b501
pushq %r14
pushq %rbx
pushq %rax
leaq 0x63d6aa4(%rip), %rbx   # 0x63f1f80
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x43a0
incq %r14
movslq 0x63d6e8f(%rip), %rax   # 0x63f2380
addq $0x8, %rbx
cmpq %rax, %r14
jl 0x1b4df
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::createReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::Config> const&)
Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
        Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
        if( !reporter ) {
            std::ostringstream oss;
            oss << "No reporter registered with name: '" << reporterName << "'";
            throw std::domain_error( oss.str() );
        }
        return reporter;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd3ca
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r15
movq (%r12), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0xd272
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rax
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %r15
movq %rax, (%r14)
testq %rax, %rax
je 0xd297
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd2a7
movq (%rdi), %rax
callq *0x18(%rax)
testq %r15, %r15
je 0xd2bf
movq %r14, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0xc5f0
leaq 0x39606(%rip), %rsi     # 0x468d6
leaq 0x28(%rsp), %rdi
movl $0x23, %edx
callq 0xc530
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0xc530
leaq 0x39f2f(%rip), %rsi     # 0x47226
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movl $0x10, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc6f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xc570
xorl %ebp, %ebp
movq 0x54c0f(%rip), %rsi     # 0x61f48
movq 0x54c38(%rip), %rdx     # 0x61f78
movq %r14, %rdi
callq 0xc7d0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd36e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xd36e
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0xd380
movq %r14, %rdi
callq 0xc360
jmp 0xd380
movq %rax, %rbx
movq 0x54c01(%rip), %rsi     # 0x61f88
leaq 0x28(%rsp), %rdi
callq 0xc220
leaq 0x98(%rsp), %rdi
callq 0xc120
jmp 0xd3ba
movq %rax, %rbx
jmp 0xd3ba
jmp 0xd3c2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd3ba
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::cleanUp()
inline RegistryHub*& getTheRegistryHub() {
            static RegistryHub* theRegistryHub = CATCH_NULL;
            if( !theRegistryHub )
                theRegistryHub = new RegistryHub();
            return theRegistryHub;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x53aa7(%rip)     # 0x62640
jne 0xec2b
movl $0xd0, %edi
callq 0xc480
movq %rax, %rbx
leaq 0x5208d(%rip), %rax     # 0x60c40
movq %rax, (%rbx)
leaq 0x520db(%rip), %rax     # 0x60c98
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x1f058
leaq 0x52407(%rip), %rax     # 0x60fd8
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x70, %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq 0x52419(%rip), %rax     # 0x61028
movq %rax, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
movq %rcx, 0xc8(%rbx)
movq %rbx, 0x53a15(%rip)     # 0x62640
movq 0x53a0e(%rip), %rdi     # 0x62640
testq %rdi, %rdi
je 0xec3d
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x539fb(%rip)     # 0x62640
jne 0xecd7
movl $0xd0, %edi
callq 0xc480
movq %rax, %rbx
leaq 0x51fe1(%rip), %rax     # 0x60c40
movq %rax, (%rbx)
leaq 0x5202f(%rip), %rax     # 0x60c98
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x1f058
leaq 0x5235b(%rip), %rax     # 0x60fd8
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x70, %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq 0x5236d(%rip), %rax     # 0x61028
movq %rax, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
movq %rcx, 0xc8(%rbx)
movq %rbx, 0x53969(%rip)     # 0x62640
movq $0x0, 0x5395e(%rip) # 0x62640
movq 0x53897(%rip), %rdi     # 0x62580
testq %rdi, %rdi
je 0xecf4
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x53881(%rip) # 0x62580
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xed09
movq %rax, %r14
movl $0xd0, %esi
movq %rbx, %rdi
callq 0xc4a0
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x98, %esi
addq (%r14), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x1b096
movq (%r15), %rax
cmpq 0x8(%r15), %rax
jne 0xd508
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x39429(%rip), %rsi     # 0x468fa
leaq 0x39429(%rip), %rdx     # 0x46901
leaq 0x10(%rsp), %rdi
callq 0x32d7e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x32e0e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xd508
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq $0x0, (%rbx)
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rbp
cmpq %rbp, %r15
je 0xd578
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xd235
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xd612
movq %rbx, %rdi
movq %r13, %rsi
callq 0x14df0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd55f
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd56f
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x20, %r15
cmpq %rbp, %r15
jne 0xd528
leaq 0x30(%rsp), %rdi
callq 0x14e2c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xd5f4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xd5f4
movq %rax, %r14
jmp 0xd5f4
jmp 0xd60a
jmp 0xd60a
movq %rax, %r14
jmp 0xd5e6
movq %rax, %r14
jmp 0xd5d6
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd5d6
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd5e6
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd5f4
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x30(%rsp), %rdi
callq 0x14e2c
movq %r14, %rdi
callq 0xc820
jmp 0xd60a
jmp 0xd60a
movq %rax, %rdi
callq 0x15d1b
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xd65c
movq %rsi, %r15
leaq 0x53547(%rip), %rsi     # 0x60b80
leaq 0x53778(%rip), %rdx     # 0x60db8
xorl %ecx, %ecx
callq 0xc520
testq %rax, %rax
je 0xd669
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14df0
jmp 0xd6d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14df0
jmp 0xd6e4
movl $0x28, %edi
callq 0xc480
movq %rax, %r12
movl $0x0, 0x8(%rax)
leaq 0x53b7c(%rip), %rax     # 0x61200
movq %rax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq $0x0, 0x20(%r12)
movq %rsp, %rsi
movq %r12, (%rsi)
movl $0x1, 0x8(%r12)
movq %rbx, %rdi
callq 0x14df0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd6c0
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, (%r15)
je 0xd6d5
movq %r12, %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x211f0
addq $0x10, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x211f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xd726
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd710
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xd710
jmp 0xd726
jmp 0xd70d
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd71e
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0xc820
movq %rax, %rdi
callq 0x15d1b
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
callq 0xd3ca
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14e88
movq (%rbx), %r12
movq 0x8(%rbx), %rbp
cmpq %rbp, %r12
je 0xd821
leaq 0x10(%rsp), %r13
movq (%r12), %rbx
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x18(%rsp)
movq (%r15), %rdi
movq %rdi, 0x20(%rsp)
testq %rdi, %rdi
je 0xd7a8
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq *0x20(%rax)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd7c9
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r13, %rdi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0xd612
movq %r14, %rdi
movq %r13, %rsi
callq 0x14df0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd7f4
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd804
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xd814
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %r12
cmpq %rbp, %r12
jne 0xd783
movq (%r14), %rdi
movq 0x28(%rsp), %rbx
movq %rdi, (%rbx)
testq %rdi, %rdi
je 0xd837
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x14f10
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd8a6
jmp 0xd89e
jmp 0xd89e
jmp 0xd89e
movq %rax, %rbx
jmp 0xd873
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd873
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd88c
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xd88c
jmp 0xd89e
jmp 0xd89e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xd8a9
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xd8a9
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x14f10
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rdi
callq 0x20760
leaq 0x90(%rbx), %rdi
movq %rdi, 0x28(%rsp)
callq 0x338ce
leaq 0x30(%rsp), %rdi
callq 0xc5f0
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0xe190
leaq 0x30(%rsp), %rbp
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %rbp, %rdi
leaq 0x38bf0(%rip), %rsi     # 0x46cf3
callq 0xc530
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
movq %rbp, %rdi
callq 0xc530
movl $0x1, %edx
movq %rax, %rdi
leaq 0x393b9(%rip), %rsi     # 0x474e2
callq 0xc530
leaq 0x20(%r12), %rsi
movq %r13, %rdi
callq 0xf9fe
movl 0x108(%rbx), %r15d
movq %r13, %rdi
callq 0x15e5a
orl %r15d, %eax
movl %eax, 0x108(%rbx)
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x33016
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe17c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %r12, %rdi
callq 0xc540
movq %rax, %r12
cmpq %r14, %rax
jne 0xe0f4
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xc6f0
addq $0xc0, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc590
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe1d0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x53db1(%rip), %rsi     # 0x61f88
leaq 0x30(%rsp), %rdi
callq 0xc220
leaq 0xa0(%rsp), %rdi
callq 0xc120
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe225
jmp 0xe225
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe228
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xe228
movq %rax, %rbx
movq 0x53d59(%rip), %rsi     # 0x61f88
leaq 0x30(%rsp), %rdi
callq 0xc220
leaq 0xa0(%rsp), %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::operator<<(std::ostream&, Catch::SourceLineInfo const&)
std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
        os << info.file << "(" << info.line << ")";
#else
        os << info.file << ":" << info.line;
#endif
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
callq 0xc530
movq %rax, %r15
leaq 0x38880(%rip), %rsi     # 0x46c5c
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0xc300
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0x5075075075075075, %rsi # imm = 0xAF8AF8AF8AF8AF8B
imulq %rax, %rsi
callq 0x15aac
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0xe493
movq %r15, %rdi
movq %r12, %rsi
callq 0x15a1e
testb %al, %al
je 0xe48a
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testb %al, %al
jne 0xe47f
testb $0x10, 0x108(%r12)
jne 0xe48a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15b56
addq $0x118, %r12            # imm = 0x118
jmp 0xe453
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe4a2
movq %rax, %r14
movq %rbx, %rdi
callq 0x15b86
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0xe6a0
movq %rax, %rbx
leaq 0x70(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x14db2
leaq 0x50(%rsp), %rdi
movq %rbp, %rsi
callq 0x15bb5
movq (%r12), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x14db2
movq 0x8(%r12), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x14db2
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r15, %rsi
movq %r14, %r9
callq 0xe769
movq (%rbx), %rax
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0xe569
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x90(%rsp), %rdi
callq 0x16074
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe591
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe5ac
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe5c7
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc4a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe5e8
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xc4a0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x15d1b
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x15cf4
jmp 0xe617
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe637
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xe637
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe657
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xe657
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe677
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xe677
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe698
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::NotImplementedException::NotImplementedException(Catch::SourceLineInfo const&)
NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
    :   m_lineInfo( lineInfo ) {
        std::ostringstream oss;
        oss << lineInfo << ": function ";
        oss << "not implemented";
        m_what = oss.str();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50852(%rip), %rax     # 0x5f5d8
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rbp
movq %rbp, 0x28(%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x32cee
movq 0x20(%r12), %rax
movq %rax, 0x48(%rbx)
leaq 0x20(%rsp), %rdi
callq 0xc5f0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0xe3bb
leaq 0x37b6c(%rip), %rsi     # 0x46953
leaq 0x20(%rsp), %rdi
movl $0xb, %edx
callq 0xc530
leaq 0x37b62(%rip), %rsi     # 0x4695f
leaq 0x20(%rsp), %rdi
movl $0xf, %edx
callq 0xc530
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xc6f0
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc590
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xee41
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
movq 0x53140(%rip), %rsi     # 0x61f88
leaq 0x20(%rsp), %rdi
callq 0xc220
leaq 0x90(%rsp), %rdi
callq 0xc120
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xee7d
movq %rax, %r12
jmp 0xee9e
movq %rax, %r12
jmp 0xeeb2
movq %rax, %r12
movq 0x53101(%rip), %rsi     # 0x61f88
leaq 0x20(%rsp), %rdi
callq 0xc220
leaq 0x90(%rsp), %rdi
callq 0xc120
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0xeeb2
movq (%rbp), %rsi
incq %rsi
callq 0xc4a0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0xeec6
movq (%r13), %rsi
incq %rsi
callq 0xc4a0
movq %rbx, %rdi
callq 0xc870
movq %r12, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::FileStream::FileStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
FileStream::FileStream( std::string const& filename ) {
        m_ofs.open( filename.c_str() );
        if( m_ofs.fail() ) {
            std::ostringstream oss;
            oss << "Unable to open file: '" << filename << "'";
            throw std::domain_error( oss.str() );
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5070a(%rip), %rax     # 0x5f600
movq %rax, (%rdi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xc7c0
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0xc070
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0xef31
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
callq 0xc5f0
leaq 0x37a2d(%rip), %rsi     # 0x4696f
leaq 0x20(%rsp), %rdi
movl $0x16, %edx
callq 0xc530
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0xc530
leaq 0x382bd(%rip), %rsi     # 0x47226
movl $0x1, %edx
movq %rax, %rdi
callq 0xc530
movl $0x10, %edi
callq 0xc1f0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xc6f0
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc570
xorl %ebp, %ebp
movq 0x52fa1(%rip), %rsi     # 0x61f48
movq 0x52fca(%rip), %rdx     # 0x61f78
movq %r14, %rdi
callq 0xc7d0
movq %rax, %r15
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xefdc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc4a0
jmp 0xefdc
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0xefee
movq %r14, %rdi
callq 0xc360
jmp 0xefee
movq %rax, %r15
movq 0x52f93(%rip), %rsi     # 0x61f88
leaq 0x20(%rsp), %rdi
callq 0xc220
leaq 0x90(%rsp), %rdi
callq 0xc120
jmp 0xf013
jmp 0xf010
movq %rax, %r15
movq %rbx, %rdi
callq 0xc690
movq %r15, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::Colour::use(Catch::Colour::Code)
void Colour::use( Code _colourCode ) {
        static IColourImpl* impl = isDebuggerActive()
            ? NoColourImpl::instance()
            : platformColourInstance();
        impl->use( _colourCode );
    }

// Assembly:
pushq %rbx
movl %edi, %ebx
movb 0x5341f(%rip), %al      # 0x62590
testb %al, %al
je 0xf188
movq 0x5340c(%rip), %rdi     # 0x62588
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl %ebx, %esi
popq %rbx
jmpq *%rax
leaq 0x53401(%rip), %rdi     # 0x62590
callq 0xc850
testl %eax, %eax
je 0xf175
callq 0xf200
movq %rax, 0x533e4(%rip)     # 0x62588
leaq 0x533e5(%rip), %rdi     # 0x62590
callq 0xc2b0
jmp 0xf175
movq %rax, %rbx
leaq 0x533d4(%rip), %rdi     # 0x62590
callq 0xc290
movq %rbx, %rdi
callq 0xc820
nop