.file	"ltalloc.cc"
	.intel_syntax noprefix
 # GNU C++11 (Rev3, Built by MSYS2 project) version 6.3.0 (i686-w64-mingw32)
 #	compiled by GNU C version 6.3.0, GMP version 6.1.2, MPFR version 3.1.5-p2, MPC version 1.0.3, isl version 0.15
 # GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
 # options passed: 
 # -iprefix C:/msys64/mingw32/bin/../lib/gcc/i686-w64-mingw32/6.3.0/
 # -D_REENTRANT -D _WIN32 -D WIN32 ltalloc.cc -masm=intel -mconsole
 # -mno-stack-arg-probe -mtune=generic -march=i686 -O3 -Wall -std=c++11
 # -fverbose-asm -ffreestanding -fstack-check=no -fno-stack-protector
 # -fno-inline-functions -fno-exceptions -fno-asynchronous-unwind-tables
 # options enabled:  -faggressive-loop-optimizations -falign-labels
 # -fauto-inc-dec -fbranch-count-reg -fcaller-saves
 # -fchkp-check-incomplete-type -fchkp-check-read -fchkp-check-write
 # -fchkp-instrument-calls -fchkp-narrow-bounds -fchkp-optimize
 # -fchkp-store-bounds -fchkp-use-static-bounds
 # -fchkp-use-static-const-bounds -fchkp-use-wrappers
 # -fcombine-stack-adjustments -fcommon -fcompare-elim -fcprop-registers
 # -fcrossjumping -fcse-follow-jumps -fdefer-pop
 # -fdelete-null-pointer-checks -fdevirtualize -fdevirtualize-speculatively
 # -fdwarf2-cfi-asm -fearly-inlining -feliminate-unused-debug-types
 # -fexpensive-optimizations -fforward-propagate -ffunction-cse -fgcse
 # -fgcse-after-reload -fgcse-lm -fgnu-runtime -fgnu-unique
 # -fguess-branch-probability -fhoist-adjacent-loads -fident
 # -fif-conversion -fif-conversion2 -findirect-inlining -finline
 # -finline-atomics -finline-functions-called-once -finline-small-functions
 # -fipa-cp -fipa-cp-alignment -fipa-cp-clone -fipa-icf -fipa-icf-functions
 # -fipa-icf-variables -fipa-profile -fipa-pure-const -fipa-ra
 # -fipa-reference -fipa-sra -fira-hoist-pressure -fira-share-save-slots
 # -fira-share-spill-slots -fisolate-erroneous-paths-dereference -fivopts
 # -fkeep-inline-dllexport -fkeep-static-consts -fleading-underscore
 # -flifetime-dse -flra-remat -flto-odr-type-merging -fmath-errno
 # -fmerge-constants -fmerge-debug-strings -fmove-loop-invariants
 # -fomit-frame-pointer -foptimize-sibling-calls -foptimize-strlen
 # -fpartial-inlining -fpeephole -fpeephole2 -fplt -fpredictive-commoning
 # -fprefetch-loop-arrays -free -freg-struct-return -freorder-blocks
 # -freorder-functions -frerun-cse-after-loop
 # -fsched-critical-path-heuristic -fsched-dep-count-heuristic
 # -fsched-group-heuristic -fsched-interblock -fsched-last-insn-heuristic
 # -fsched-rank-heuristic -fsched-spec -fsched-spec-insn-heuristic
 # -fsched-stalled-insns-dep -fschedule-fusion -fschedule-insns2
 # -fsemantic-interposition -fset-stack-executable -fshow-column
 # -fshrink-wrap -fsigned-zeros -fsplit-ivs-in-unroller -fsplit-paths
 # -fsplit-wide-types -fssa-backprop -fssa-phiopt -fstdarg-opt
 # -fstrict-aliasing -fstrict-overflow -fstrict-volatile-bitfields
 # -fsync-libcalls -fthread-jumps -ftoplevel-reorder -ftrapping-math
 # -ftree-bit-ccp -ftree-builtin-call-dce -ftree-ccp -ftree-ch
 # -ftree-coalesce-vars -ftree-copy-prop -ftree-cselim -ftree-dce
 # -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre
 # -ftree-loop-if-convert -ftree-loop-im -ftree-loop-ivcanon
 # -ftree-loop-optimize -ftree-loop-vectorize -ftree-parallelize-loops=
 # -ftree-partial-pre -ftree-phiprop -ftree-pre -ftree-pta -ftree-reassoc
 # -ftree-scev-cprop -ftree-sink -ftree-slp-vectorize -ftree-slsr
 # -ftree-sra -ftree-switch-conversion -ftree-tail-merge -ftree-ter
 # -ftree-vrp -funit-at-a-time -funswitch-loops -fverbose-asm
 # -fzero-initialized-in-bss -m32 -m80387 -m96bit-long-double
 # -malign-double -malign-stringops -mavx256-split-unaligned-load
 # -mavx256-split-unaligned-store -mfancy-math-387 -mfp-ret-in-387
 # -mieee-fp -mlong-double-80 -mms-bitfields -mno-red-zone -mno-sse4
 # -mpush-args -msahf -mstv -mvzeroupper

	.text
	.p2align 4,,15
	.def	_sys_free;	.scl	3;	.type	32;	.endef
_sys_free:
	test	eax, eax	 # p
	je	L10	 #,
	sub	esp, 16	 #,
	push	32768	 #
	push	0	 #
	push	eax	 # p
	call	[DWORD PTR __imp__VirtualFree@12]	 #
	add	esp, 16	 #,
L10:
	rep ret
	.p2align 4,,15
	.def	_SPINLOCK_ACQUIRE;	.scl	3;	.type	32;	.endef
_SPINLOCK_ACQUIRE:
	mov	edx, 1	 # tmp91,
	xchg	edx, DWORD PTR [eax]	 #, _5,* lock
	test	edx, edx	 # _5
	je	L12	 #,
	mov	ecx, 1	 # tmp93,
	jmp	L20	 #
	.p2align 4,,10
L16:
/APP
 # 44 "ltalloc.cc" 1
	pause
 # 0 "" 2
/NO_APP
L20:
	mov	edx, DWORD PTR [eax]	 # _8, *lock_3(D)
	test	edx, edx	 # _8
	jne	L16	 #,
	mov	edx, ecx	 # _9, tmp93
	xchg	edx, DWORD PTR [eax]	 #, _9,* lock
	test	edx, edx	 # _9
	jne	L16	 #,
L12:
	rep ret
	.p2align 4,,15
	.globl	_ltmalloc
	.def	_ltmalloc;	.scl	2;	.type	32;	.endef
_ltmalloc:
	push	ebp	 #
	push	edi	 #
	push	esi	 #
	push	ebx	 #
	sub	esp, 28	 #,
	mov	edx, DWORD PTR [esp+48]	 # size, size
	lea	eax, [edx+3]	 # tmp196,
	and	eax, -4	 # size,
	sub	eax, 1	 # _19,
	mov	ebx, eax	 # tmp198, _19
	or	ebx, 1	 # tmp198,
	bsr	ebx, ebx	 # index, tmp198
	lea	ecx, [ebx-2]	 # tmp199,
	shr	eax, cl	 # tmp200, tmp199
	lea	ebx, [eax+ebx*4]	 # _27,
	lea	eax, [ebx+ebx*2]	 # tmp471,
	sal	eax, 2	 # tmp207,
	mov	ecx, DWORD PTR __ZL11threadCache[eax]	 # fb, MEM[(struct ThreadCache *)&threadCache][_27].freeList
	lea	esi, __ZL11threadCache[eax]	 # tmp208,
	test	ecx, ecx	 # fb
	je	L22	 #,
	mov	edx, DWORD PTR [ecx]	 # fb_7->next, fb_7->next
	add	DWORD PTR [esi+8], 1	 # MEM[(struct ThreadCache *)&threadCache][_27].counter,
	mov	DWORD PTR __ZL11threadCache[eax], edx	 # MEM[(struct ThreadCache *)&threadCache][_27].freeList, fb_7->next
L21:
	add	esp, 28	 #,
	mov	eax, ecx	 #, <retval>
	pop	ebx	 #
	pop	esi	 #
	pop	edi	 #
	pop	ebp	 #
	ret
	.p2align 4,,10
L22:
	lea	ecx, [edx-1]	 # tmp235,
	cmp	ecx, 57343	 # tmp235,
	ja	L24	 #,
	mov	ecx, DWORD PTR [esi+4]	 # fb, MEM[(struct ThreadCache *)&threadCache][_27].tempList
	mov	DWORD PTR [esi+8], 1	 # MEM[(struct ThreadCache *)&threadCache][_27].counter,
	test	ecx, ecx	 # fb
	je	L25	 #,
	mov	edx, DWORD PTR [ecx]	 # fb_32->next, fb_32->next
	mov	DWORD PTR [esi+4], 0	 # MEM[(struct ThreadCache *)&threadCache][_27].tempList,
	mov	DWORD PTR __ZL11threadCache[eax], edx	 # MEM[(struct ThreadCache *)&threadCache][_27].freeList, fb_32->next
	jmp	L21	 #
L24:
	add	edx, 65535	 # tmp467,
	push	4	 #
	push	12288	 #
	xor	dx, dx	 # size
	push	edx	 # size
	push	0	 #
	call	[DWORD PTR __imp__VirtualAlloc@16]	 #
	mov	ecx, eax	 # <retval>,
	jmp	L21	 #
L25:
	mov	esi, ebx	 # tmp272, _27
	sal	esi, 6	 # tmp272,
	lea	edi, __ZL12centralCache[esi]	 # _34,
	mov	eax, edi	 #, _34
	call	_SPINLOCK_ACQUIRE	 #
	mov	ecx, DWORD PTR [edi+12]	 # _35, MEM[(struct CentralCache *)&centralCache][_27].D.21397.firstBatch
	test	ecx, ecx	 # _35
	je	L27	 #,
	cmp	ebx, 14	 # _27,
	jbe	L55	 #,
	mov	eax, DWORD PTR [ecx+4]	 # _35->nextBatch, _35->nextBatch
	mov	DWORD PTR [edi+12], eax	 # MEM[(struct CentralCache *)&centralCache][_27].D.21397.firstBatch, _35->nextBatch
L54:
	mov	DWORD PTR __ZL12centralCache[esi], 0	 #,,
	mov	edx, DWORD PTR [ecx]	 # fb_149->next, fb_149->next
	lea	eax, [ebx+ebx*2]	 # tmp463,
	mov	DWORD PTR __ZL11threadCache[0+eax*4], edx	 # MEM[(struct ThreadCache *)&threadCache][_27].freeList, fb_149->next
	jmp	L21	 #
L27:
	mov	edx, ebx	 # _39, _27
	mov	eax, 65535	 # tmp278,
	shr	edx, 2	 # _39,
	mov	ecx, edx	 # tmp500, _39
	shr	eax, cl	 # tmp277, tmp500
	mov	ecx, ebx	 # tmp280, _27
	movzx	eax, al	 # _41, tmp277
	sal	ecx, 6	 # tmp280,
	mov	DWORD PTR [esp+8], eax	 # %sfp, _41
	lea	ebp, [eax+1]	 # batchSize,
	mov	eax, ecx	 # tmp280, tmp280
	add	eax, OFFSET FLAT:__ZL12centralCache	 # tmp281,
	mov	ecx, DWORD PTR [eax+16]	 # _43, MEM[(struct CentralCache *)&centralCache][_27].freeList
	test	ecx, ecx	 # _43
	je	L28	 #,
	mov	edi, DWORD PTR [esp+8]	 # _41, %sfp
	mov	edx, DWORD PTR [eax+20]	 # _44, MEM[(struct CentralCache *)&centralCache][_27].freeListSize
	add	edi, 2	 # _41,
	cmp	edx, edi	 # _44, tmp287
	ja	L29	 #,
	imul	edi, ebx, 12	 # tmp289, _27,
	sub	ebp, edx	 # tmp292, _44
	mov	DWORD PTR [eax+20], 0	 # MEM[(struct CentralCache *)&centralCache][_27].freeListSize,
	lea	edx, [ebp+1]	 # tmp294,
	mov	DWORD PTR [eax+16], 0	 # MEM[(struct CentralCache *)&centralCache][_27].freeList,
	mov	DWORD PTR __ZL11threadCache[edi+8], edx	 # MEM[(struct ThreadCache *)&threadCache][_27].counter, tmp294
L30:
	mov	DWORD PTR __ZL12centralCache[esi], 0	 #,,
	imul	ebx, ebx, 12	 # tmp315, _27,
	mov	eax, DWORD PTR [ecx]	 # _43->next,* _43
	mov	DWORD PTR __ZL11threadCache[ebx], eax	 # MEM[(struct ThreadCache *)&threadCache][_27].freeList, _43->next
	jmp	L21	 #
L55:
	cmp	DWORD PTR [ecx+12], 0	 # MEM[(struct ChunkSm *)_35].numBatches,
	je	L78	 #,
L56:
	mov	eax, DWORD PTR [ecx+12]	 # tmp543, cs_145->numBatches
	sub	eax, 1	 # _147,
	mov	DWORD PTR [ecx+12], eax	 # cs_145->numBatches, _147
	mov	ecx, DWORD PTR [ecx+16+eax*4]	 # _35, cs_145->batches
	jmp	L54	 #
L29:
	sub	edx, ebp	 # tmp307, batchSize
	mov	DWORD PTR [eax+20], edx	 # MEM[(struct CentralCache *)&centralCache][_27].freeListSize, tmp307
	mov	eax, ecx	 # b, _43
	jmp	L32	 #
L79:
	mov	eax, DWORD PTR [eax]	 # b, b_55->next
L32:
	sub	ebp, 1	 # batchSize,
	jne	L79	 #,
	mov	edi, DWORD PTR [eax]	 # b_55->next, b_55->next
	mov	edx, ebx	 # tmp309, _27
	sal	edx, 6	 # tmp309,
	mov	DWORD PTR __ZL12centralCache[edx+16], edi	 # MEM[(struct CentralCache *)&centralCache][_27].freeList, b_55->next
	mov	DWORD PTR [eax], 0	 # b_55->next,
	jmp	L30	 #
L28:
	cmp	ebx, 7	 # _27,
	jbe	L80	 #,
	lea	eax, [ebx-3]	 # c,
	mov	edx, eax	 # tmp319, c
	shr	eax, 2	 # tmp321,
	and	edx, 3	 # tmp319,
	lea	ecx, [eax-2]	 # tmp322,
	or	edx, 4	 # tmp320,
	sal	edx, cl	 # tmp320, tmp322
	mov	DWORD PTR [esp], edx	 # %sfp, tmp320
L34:
	mov	edx, ebx	 # tmp324, _27
	sal	edx, 6	 # tmp324,
	add	edx, OFFSET FLAT:__ZL12centralCache	 # tmp325,
	mov	eax, DWORD PTR [edx+4]	 # _70, MEM[(struct CentralCache *)&centralCache][_27].freeBlocksInLastChunk
	test	eax, eax	 # _70
	je	L35	 #,
	cmp	ebp, eax	 # batchSize, _70
	mov	ecx, DWORD PTR [edx+8]	 # firstFree, MEM[(struct CentralCache *)&centralCache][_27].lastChunk
	jbe	L36	 #,
	imul	edi, ebx, 12	 # tmp332, _27,
	sub	ebp, eax	 # tmp335, _70
	mov	DWORD PTR [edx+4], 0	 # MEM[(struct CentralCache *)&centralCache][_27].freeBlocksInLastChunk,
	add	ebp, 1	 # tmp337,
	mov	DWORD PTR __ZL11threadCache[edi+8], ebp	 # MEM[(struct ThreadCache *)&threadCache][_27].counter, tmp337
	mov	edi, DWORD PTR [esp]	 # tmp342, %sfp
	mov	ebp, eax	 # batchSize, _70
	imul	edi, eax	 # tmp342, _70
	add	edi, ecx	 # _79, firstFree
	mov	DWORD PTR [edx+8], edi	 # MEM[(struct CentralCache *)&centralCache][_27].lastChunk, _79
L37:
	mov	edx, DWORD PTR [edi-4]	 # _80, MEM[(char * *)_142 + 4294967292B]
	mov	edi, ebx	 # tmp357, _27
	sal	edi, 6	 # tmp357,
	mov	DWORD PTR __ZL12centralCache[edi+8], edx	 # MEM[(struct CentralCache *)&centralCache][_27].lastChunk, _80
	add	edi, OFFSET FLAT:__ZL12centralCache	 # tmp358,
	test	edx, edx	 # _80
	je	L38	 #,
	movzx	edx, dx	 # _80, _80
	mov	eax, 65536	 # tmp366,
	sub	eax, edx	 # tmp365, _80
	xor	edx, edx	 # tmp368
	div	DWORD PTR [esp]	 # %sfp
	mov	DWORD PTR [edi+4], eax	 # MEM[(struct CentralCache *)&centralCache][_27].freeBlocksInLastChunk, tmp367
L38:
	sub	ebp, 1	 # batchSize,
	mov	eax, ecx	 # _88, firstFree
	mov	DWORD PTR __ZL12centralCache[esi], 0	 #,,
	je	L39	 #,
	mov	esi, DWORD PTR [esp]	 # tmp370, %sfp
	mov	edx, ebp	 # batchSize, batchSize
	neg	esi	 # tmp370
L40:
	add	eax, DWORD PTR [esp]	 # _88, %sfp
	sub	edx, 1	 # batchSize,
	mov	DWORD PTR [eax+esi], eax	 # MEM[base: _88, index: _226, offset: 0B], _88
	jne	L40	 #,
	imul	ebp, DWORD PTR [esp]	 # tmp371, %sfp
	lea	eax, [ecx+ebp]	 # firstFree,
L39:
	mov	DWORD PTR [eax], 0	 # MEM[(struct FreeBlock *)firstFree_37].next,
	mov	eax, DWORD PTR [ecx]	 # MEM[(struct FreeBlock *)firstFree_71].next,* firstFree
	imul	ebx, ebx, 12	 # tmp373, _27,
	mov	DWORD PTR __ZL11threadCache[ebx], eax	 # MEM[(struct ThreadCache *)&threadCache][_27].freeList, MEM[(struct FreeBlock *)firstFree_71].next
	jmp	L21	 #
L36:
	mov	edi, DWORD PTR [esp]	 # tmp351, %sfp
	sub	eax, ebp	 # _76, batchSize
	mov	DWORD PTR [edx+4], eax	 # MEM[(struct CentralCache *)&centralCache][_27].freeBlocksInLastChunk, _76
	imul	edi, ebp	 # tmp351, batchSize
	add	edi, ecx	 # _79, firstFree
	test	eax, eax	 # _76
	mov	DWORD PTR [edx+8], edi	 # MEM[(struct CentralCache *)&centralCache][_27].lastChunk, _79
	jne	L38	 #,
	jmp	L37	 #
L78:
	mov	ecx, DWORD PTR [ecx+4]	 # cs, MEM[(struct ChunkSm *)_35].prev
	test	ecx, ecx	 # cs
	je	L27	 #,
	mov	DWORD PTR [edi+12], ecx	 # MEM[(struct CentralCache *)&centralCache][_27].D.21397.chunkWithFreeBatches, cs
	jmp	L56	 #
L35:
	mov	DWORD PTR __ZL12centralCache[esi], 0	 #,,
	mov	eax, OFFSET FLAT:__ZL3pad	 #,
	call	_SPINLOCK_ACQUIRE	 #
	mov	ecx, DWORD PTR __ZL3pad+4	 # <retval>, pad.freeChunk
	test	ecx, ecx	 # <retval>
	je	L41	 #,
	mov	eax, DWORD PTR [ecx]	 # _91, MEM[(void * *)_90]
	sub	DWORD PTR __ZL3pad+8, 65536	 # pad.size,
	mov	DWORD PTR __ZL3pad+4, eax	 # pad.freeChunk, _91
	mov	DWORD PTR __ZL3pad, 0	 #,,
	mov	DWORD PTR [ecx+65532], 0	 # MEM[(char * *)_90 + 65532B],
L42:
	cmp	ebx, 15	 # _27,
	sbb	eax, eax	 # iftmp.2_101
	xor	edx, edx	 # tmp389
	xor	al, al	 # iftmp.2_101
	add	eax, 65472	 # iftmp.2_101,
	div	DWORD PTR [esp]	 # %sfp
	cmp	ebp, eax	 # batchSize, tmp388
	mov	DWORD PTR [esp+4], eax	 # %sfp, tmp388
	jbe	L44	 #,
	mov	eax, DWORD PTR [esp+8]	 # _41, %sfp
	mov	ebp, DWORD PTR [esp+4]	 # tmp388, %sfp
	imul	edx, ebx, 12	 # tmp391, _27,
	add	eax, 2	 # _41,
	sub	eax, ebp	 # tmp395, tmp388
	mov	DWORD PTR __ZL11threadCache[edx+8], eax	 # MEM[(struct ThreadCache *)&threadCache][_27].counter, tmp395
L44:
	mov	eax, DWORD PTR [esp]	 # tmp396, %sfp
	mov	edx, ecx	 # tmp397, <retval>
	mov	DWORD PTR [ecx], ebx	 # MEM[(struct Chunk *)p_106].sizeClass, _27
	imul	eax, DWORD PTR [esp+4]	 # tmp396, %sfp
	mov	DWORD PTR [esp+12], ebp	 # %sfp, batchSize
	sub	edx, eax	 # tmp397, tmp396
	mov	eax, edx	 # tmp397, tmp397
	mov	edx, DWORD PTR [esp]	 # tmp476, %sfp
	add	eax, 65536	 # firstFree,
	mov	DWORD PTR [esp+8], eax	 # %sfp, firstFree
	neg	edx	 # tmp476
	jmp	L46	 #
L81:
	add	eax, DWORD PTR [esp]	 # _115, %sfp
	mov	DWORD PTR [eax+edx], eax	 # MEM[base: _115, index: _225, offset: 0B], _115
L46:
	sub	DWORD PTR [esp+12], 1	 # %sfp,
	jne	L81	 #,
	mov	edx, DWORD PTR [esp]	 # _77, %sfp
	lea	eax, [ebp-1]	 # tmp400,
	mov	DWORD PTR [esp+12], ecx	 # %sfp, <retval>
	imul	eax, edx	 # tmp401, _77
	add	eax, DWORD PTR [esp+8]	 # firstFree, %sfp
	mov	DWORD PTR [eax], 0	 # MEM[(struct FreeBlock *)firstFree_257].next,
	add	eax, edx	 # firstFree, _77
	mov	DWORD PTR [esp], eax	 # %sfp, firstFree
	mov	eax, edi	 #, _34
	call	_SPINLOCK_ACQUIRE	 #
	mov	eax, ebx	 # tmp403, _27
	mov	ecx, DWORD PTR [esp+12]	 # <retval>, %sfp
	sal	eax, 6	 # tmp403,
	mov	eax, DWORD PTR __ZL12centralCache[eax+24]	 # _117, MEM[(struct CentralCache *)&centralCache][_27].minChunkAddr
	cmp	ecx, eax	 # <retval>, _117
	jb	L60	 #,
	test	eax, eax	 # _117
	je	L60	 #,
L47:
	mov	eax, ebx	 # tmp415, _27
	sal	eax, 6	 # tmp415,
	add	eax, OFFSET FLAT:__ZL12centralCache	 # tmp416,
	cmp	ecx, DWORD PTR [eax+28]	 # <retval>, MEM[(struct CentralCache *)&centralCache][_27].maxChunkAddr
	jbe	L49	 #,
	mov	DWORD PTR [eax+28], ecx	 # MEM[(struct CentralCache *)&centralCache][_27].maxChunkAddr, <retval>
L49:
	cmp	ebx, 14	 # _27,
	jbe	L82	 #,
L50:
	mov	eax, ebx	 # tmp431, _27
	sal	eax, 6	 # tmp431,
	add	eax, OFFSET FLAT:__ZL12centralCache	 # tmp432,
	cmp	DWORD PTR [eax+4], 0	 # MEM[(struct CentralCache *)&centralCache][_27].freeBlocksInLastChunk,
	je	L53	 #,
	mov	edx, DWORD PTR [eax+8]	 # _131, MEM[(struct CentralCache *)&centralCache][_27].lastChunk
	mov	eax, DWORD PTR [esp]	 # tmp438, %sfp
	xor	ax, ax	 # tmp438
	mov	DWORD PTR [eax+65532], edx	 # *_130, _131
L53:
	mov	edx, DWORD PTR [esp+4]	 # tmp388, %sfp
	mov	edi, DWORD PTR [esp]	 # firstFree, %sfp
	mov	eax, ebx	 # tmp440, _27
	sal	eax, 6	 # tmp440,
	mov	ecx, DWORD PTR [esp+8]	 # _35, %sfp
	sub	edx, ebp	 # tmp388, batchSize
	mov	DWORD PTR __ZL12centralCache[eax+8], edi	 # MEM[(struct CentralCache *)&centralCache][_27].lastChunk, firstFree
	mov	DWORD PTR __ZL12centralCache[eax+4], edx	 # MEM[(struct CentralCache *)&centralCache][_27].freeBlocksInLastChunk, tmp443
	jmp	L54	 #
L41:
	mov	DWORD PTR __ZL3pad, ecx	 #,, <retval>
	push	4	 #
	push	12288	 #
	push	65536	 #
	push	0	 #
	call	[DWORD PTR __imp__VirtualAlloc@16]	 #
	test	eax, eax	 # <retval>
	mov	ecx, eax	 # <retval>,
	jne	L42	 #,
	jmp	L21	 #
L80:
	mov	eax, 2	 # tmp318,
	mov	ecx, edx	 # tmp507, _39
	sal	eax, cl	 # tmp318, tmp507
	mov	DWORD PTR [esp], eax	 # %sfp, tmp318
	jmp	L34	 #
L82:
	mov	edx, ebx	 # tmp423, _27
	mov	DWORD PTR [ecx+12], 0	 # MEM[(struct ChunkSm *)p_106].numBatches,
	sal	edx, 6	 # tmp423,
	add	edx, OFFSET FLAT:__ZL12centralCache	 # tmp424,
	mov	eax, DWORD PTR [edx+12]	 # _120, MEM[(struct CentralCache *)&centralCache][_27].D.21397.chunkWithFreeBatches
	test	eax, eax	 # _120
	mov	DWORD PTR [ecx+4], eax	 # MEM[(struct ChunkSm *)p_106].prev, _120
	je	L51	 #,
	mov	edx, DWORD PTR [eax+8]	 # _121, _120->next
	mov	DWORD PTR [ecx+8], edx	 # MEM[(struct ChunkSm *)p_106].next, _121
	mov	edx, DWORD PTR [eax+8]	 # _122, _120->next
	test	edx, edx	 # _122
	je	L52	 #,
	mov	DWORD PTR [edx+4], ecx	 # _122->prev, <retval>
L52:
	mov	DWORD PTR [eax+8], ecx	 # _120->next, <retval>
	jmp	L50	 #
L51:
	mov	DWORD PTR [ecx+8], 0	 # MEM[(struct ChunkSm *)p_106].next,
	mov	DWORD PTR [edx+12], ecx	 # MEM[(struct CentralCache *)&centralCache][_27].D.21397.chunkWithFreeBatches, <retval>
	jmp	L50	 #
L60:
	mov	eax, ebx	 # tmp411, _27
	sal	eax, 6	 # tmp411,
	mov	DWORD PTR __ZL12centralCache[eax+24], ecx	 # MEM[(struct CentralCache *)&centralCache][_27].minChunkAddr, <retval>
	jmp	L47	 #
	.p2align 4,,15
	.globl	_ltfree
	.def	_ltfree;	.scl	2;	.type	32;	.endef
_ltfree:
	mov	eax, DWORD PTR [esp+4]	 # p, p
	test	ax, ax	 # p
	je	L84	 #,
	mov	edx, eax	 # tmp95, p
	xor	dx, dx	 # tmp95
	mov	edx, DWORD PTR [edx]	 # sizeClass, _9->sizeClass
	lea	edx, [edx+edx*2]	 # tmp100,
	sal	edx, 2	 # tmp101,
	mov	ecx, DWORD PTR __ZL11threadCache[edx]	 # MEM[(struct ThreadCache *)&threadCache][sizeClass_11].freeList, MEM[(struct ThreadCache *)&threadCache][sizeClass_11].freeList
	mov	DWORD PTR [eax], ecx	 # MEM[(struct FreeBlock *)p_2(D)].next, MEM[(struct ThreadCache *)&threadCache][sizeClass_11].freeList
	mov	DWORD PTR __ZL11threadCache[edx], eax	 # MEM[(struct ThreadCache *)&threadCache][sizeClass_11].freeList, p
	ret
	.p2align 4,,10
L84:
	jmp	_sys_free	 #
	.p2align 4,,15
	.globl	_ltmsize
	.def	_ltmsize;	.scl	2;	.type	32;	.endef
_ltmsize:
	sub	esp, 44	 #,
	mov	edx, DWORD PTR [esp+48]	 # p, p
	test	dx, dx	 # p
	je	L88	 #,
	xor	dx, dx	 # tmp102
	mov	ecx, DWORD PTR [edx]	 # _12, _10->sizeClass
	cmp	ecx, 7	 # _12,
	jbe	L94	 #,
	sub	ecx, 3	 # c,
	mov	eax, ecx	 # tmp105, c
	shr	ecx, 2	 # tmp107,
	and	eax, 3	 # tmp105,
	sub	ecx, 2	 # tmp108,
	or	eax, 4	 # tmp106,
	sal	eax, cl	 # <retval>, tmp108
L87:
	add	esp, 44	 #,
	ret
	.p2align 4,,10
L88:
	xor	eax, eax	 # <retval>
	test	edx, edx	 # p
	je	L87	 #,
	sub	esp, 4	 #,
	push	28	 #
	lea	eax, [esp+12]	 # tmp109,
	push	eax	 # tmp109
	push	edx	 # p
	call	[DWORD PTR __imp__VirtualQuery@12]	 #
	mov	eax, DWORD PTR [esp+20]	 # <retval>, mi.RegionSize
	pop	edx	 #
	jmp	L87	 #
	.p2align 4,,10
L94:
	shr	ecx, 2	 # tmp103,
	mov	eax, 2	 # tmp104,
	sal	eax, cl	 # <retval>, tmp103
	jmp	L87	 #
.lcomm __ZL3pad,12,4
.lcomm __ZL11threadCache,1584,32
.lcomm __ZL12centralCache,8448,64
	.ident	"GCC: (Rev3, Built by MSYS2 project) 6.3.0"