	.section	__TEXT,__text,regular,pure_instructions
	.macosx_version_min 10, 11
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3               ## -- Begin function compressStream
LCPI0_0:
	.long	0                       ## double 256
	.long	1081081856
LCPI0_1:
	.long	0                       ## double 65536
	.long	1089470464
LCPI0_2:
	.long	0                       ## double 16777216
	.long	1097859072
LCPI0_3:
	.long	0                       ## double 4294967296
	.long	1106247680
LCPI0_4:
	.long	0                       ## double 1099511627776
	.long	1114636288
LCPI0_5:
	.long	0                       ## double 281474976710656
	.long	1123024896
LCPI0_6:
	.long	0                       ## double 72057594037927936
	.long	1131413504
LCPI0_7:
	.long	0                       ## double 8
	.long	1075838976
LCPI0_8:
	.long	0                       ## double 1
	.long	1072693248
LCPI0_9:
	.long	0                       ## double 100
	.long	1079574528
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_compressStream
	.p2align	4, 0x90
_compressStream:                        ## @compressStream
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%ebx
	pushl	%edi
	pushl	%esi
	subl	$5180, %esp             ## imm = 0x143C
	calll	L0$pb
L0$pb:
	popl	%ecx
	movl	L___stack_chk_guard$non_lazy_ptr-L0$pb(%ecx), %eax
	movl	%eax, -5176(%ebp)       ## 4-byte Spill
	movl	(%eax), %eax
	movl	%eax, -16(%ebp)
	movl	L_blockSize100k$non_lazy_ptr-L0$pb(%ecx), %eax
	movl	L_verbosity$non_lazy_ptr-L0$pb(%ecx), %edx
	movl	%ecx, -5100(%ebp)       ## 4-byte Spill
	movl	L_workFactor$non_lazy_ptr-L0$pb(%ecx), %ecx
	subl	$12, %esp
	leal	-5104(%ebp), %esi
	pushl	(%ecx)
	movl	%edx, -5112(%ebp)       ## 4-byte Spill
	pushl	(%edx)
	pushl	(%eax)
	pushl	12(%ebp)
	pushl	%esi
	calll	_BZ2_bzWriteOpen
	addl	$32, %esp
	movl	%eax, %esi
	cmpl	$0, -5104(%ebp)
	jne	LBB0_9
## BB#1:                                ## %if.end
	movl	8(%ebp), %ebx
	movl	-5112(%ebp), %eax       ## 4-byte Reload
	cmpl	$2, (%eax)
	jl	LBB0_3
## BB#2:                                ## %if.then2
	movl	-5100(%ebp), %ecx       ## 4-byte Reload
	movl	L___stderrp$non_lazy_ptr-L0$pb(%ecx), %eax
	leal	L_.str-L0$pb(%ecx), %ecx
	pushl	(%eax)
	pushl	$1
	pushl	$1
	pushl	%ecx
	calll	_fwrite$UNIX2003
	addl	$16, %esp
LBB0_3:                                 ## %if.end4
	subl	$12, %esp
	pushl	%ebx
	calll	_spec_getc
	addl	$16, %esp
	cmpl	$-1, %eax
	je	LBB0_13
## BB#4:
	leal	-5016(%ebp), %edi
	.p2align	4, 0x90
LBB0_6:                                 ## %if.end7
                                        ## =>This Inner Loop Header: Depth=1
	subl	$8, %esp
	movzbl	%al, %eax
	pushl	%ebx
	pushl	%eax
	calll	_spec_ungetc
	addl	$16, %esp
	pushl	%ebx
	pushl	$5000                   ## imm = 0x1388
	pushl	$1
	pushl	%edi
	calll	_spec_fread
	addl	$16, %esp
	testl	%eax, %eax
	jle	LBB0_8
## BB#7:                                ## %if.then10
                                        ##   in Loop: Header=BB0_6 Depth=1
	pushl	%eax
	pushl	%edi
	pushl	%esi
	leal	-5104(%ebp), %eax
	pushl	%eax
	calll	_BZ2_bzWrite
	addl	$16, %esp
LBB0_8:                                 ## %if.end12
                                        ##   in Loop: Header=BB0_6 Depth=1
	cmpl	$0, -5104(%ebp)
	jne	LBB0_9
## BB#5:                                ## %while.cond
                                        ##   in Loop: Header=BB0_6 Depth=1
	subl	$12, %esp
	pushl	%ebx
	calll	_spec_getc
	addl	$16, %esp
	cmpl	$-1, %eax
	jne	LBB0_6
LBB0_13:                                ## %while.end
	subl	$4, %esp
	leal	-5124(%ebp), %eax
	leal	-5128(%ebp), %ecx
	leal	-5132(%ebp), %edx
	leal	-5136(%ebp), %edi
	pushl	%eax
	pushl	%ecx
	pushl	%edx
	pushl	%edi
	pushl	$0
	pushl	%esi
	leal	-5104(%ebp), %eax
	pushl	%eax
	calll	_BZ2_bzWriteClose64
	addl	$32, %esp
	cmpl	$0, -5104(%ebp)
	jne	LBB0_9
## BB#14:                               ## %if.end21
	cmpl	$1, 12(%ebp)
	je	LBB0_16
## BB#15:                               ## %if.then23
	movl	-5100(%ebp), %eax       ## 4-byte Reload
	movl	L_outputHandleJustInCase$non_lazy_ptr-L0$pb(%eax), %eax
	movl	$0, (%eax)
LBB0_16:                                ## %if.end27
	movl	-5100(%ebp), %eax       ## 4-byte Reload
	movl	L_outputHandleJustInCase$non_lazy_ptr-L0$pb(%eax), %eax
	movl	$0, (%eax)
	movl	-5112(%ebp), %eax       ## 4-byte Reload
	cmpl	$0, (%eax)
	jle	LBB0_23
## BB#17:                               ## %if.then32
	movl	-5136(%ebp), %edx
	movl	-5132(%ebp), %ecx
	movl	%ecx, %eax
	orl	%edx, %eax
	je	LBB0_18
## BB#22:                               ## %if.else
	movl	%ecx, %eax
	shrl	$24, %eax
	movb	%al, -5081(%ebp)
	movl	%eax, %edi
	movl	%ecx, %eax
	shrl	$16, %eax
	movl	%eax, -5112(%ebp)       ## 4-byte Spill
	movb	%al, -5082(%ebp)
	movl	%ecx, %eax
	shrl	$8, %eax
	movl	%eax, -5120(%ebp)       ## 4-byte Spill
	movb	%al, -5083(%ebp)
	movb	%cl, -5084(%ebp)
	movl	%edx, %ebx
	shrl	$24, %ebx
	movb	%bl, -5085(%ebp)
	movl	%edx, %eax
	shrl	$16, %eax
	movb	%al, -5086(%ebp)
	movl	%eax, %esi
	movl	%edx, %eax
	shrl	$8, %eax
	movb	%al, -5087(%ebp)
	movb	%dl, -5088(%ebp)
	movzbl	%dl, %edx
	movl	%edx, -5144(%ebp)       ## 4-byte Spill
	vcvtsi2sdl	%ebx, %xmm0, %xmm0
	movzbl	%al, %eax
	movl	%eax, -5164(%ebp)       ## 4-byte Spill
	vcvtsi2sdl	%edi, %xmm1, %xmm1
	vmovsd	%xmm1, -5184(%ebp)      ## 8-byte Spill
	movl	%esi, %eax
	movzbl	%al, %eax
	movl	%eax, -5152(%ebp)       ## 4-byte Spill
	movl	-5124(%ebp), %ebx
	movl	%ebx, %eax
	shrl	$24, %eax
	movl	%eax, -5172(%ebp)       ## 4-byte Spill
	movb	%al, -5089(%ebp)
	movl	%ebx, %eax
	shrl	$16, %eax
	movl	%eax, -5168(%ebp)       ## 4-byte Spill
	movb	%al, -5090(%ebp)
	movl	%ebx, %eax
	shrl	$8, %eax
	movl	%eax, -5160(%ebp)       ## 4-byte Spill
	movb	%al, -5091(%ebp)
	movb	%bl, -5092(%ebp)
	movl	-5128(%ebp), %edx
	movl	%edx, %eax
	shrl	$24, %eax
	movl	%eax, -5156(%ebp)       ## 4-byte Spill
	movb	%al, -5093(%ebp)
	movzbl	%cl, %eax
	movl	%eax, -5148(%ebp)       ## 4-byte Spill
	movl	%edx, %ecx
	shrl	$16, %ecx
	movb	%cl, -5094(%ebp)
	movzbl	-5120(%ebp), %esi       ## 1-byte Folded Reload
	movl	%edx, %eax
	shrl	$8, %eax
	movb	%al, -5095(%ebp)
	movzbl	-5112(%ebp), %edi       ## 1-byte Folded Reload
	movl	%edi, -5112(%ebp)       ## 4-byte Spill
	movb	%dl, -5096(%ebp)
	movzbl	%dl, %edx
	movzbl	%al, %eax
	movzbl	%cl, %ecx
	vcvtsi2sdl	-5144(%ebp), %xmm2, %xmm2 ## 4-byte Folded Reload
	vcvtsi2sdl	-5164(%ebp), %xmm3, %xmm3 ## 4-byte Folded Reload
	vcvtsi2sdl	-5152(%ebp), %xmm4, %xmm4 ## 4-byte Folded Reload
	vcvtsi2sdl	-5148(%ebp), %xmm5, %xmm5 ## 4-byte Folded Reload
	vcvtsi2sdl	%esi, %xmm6, %xmm6
	movl	-5100(%ebp), %esi       ## 4-byte Reload
	vmovsd	LCPI0_0-L0$pb(%esi), %xmm7 ## xmm7 = mem[0],zero
	vmulsd	%xmm7, %xmm3, %xmm3
	vaddsd	%xmm2, %xmm3, %xmm2
	vmovsd	LCPI0_1-L0$pb(%esi), %xmm3 ## xmm3 = mem[0],zero
	vmulsd	%xmm3, %xmm4, %xmm4
	vaddsd	%xmm2, %xmm4, %xmm2
	vmovsd	LCPI0_2-L0$pb(%esi), %xmm4 ## xmm4 = mem[0],zero
	vmulsd	%xmm4, %xmm0, %xmm0
	vaddsd	%xmm2, %xmm0, %xmm0
	vmovsd	LCPI0_3-L0$pb(%esi), %xmm1 ## xmm1 = mem[0],zero
	vmovsd	%xmm1, -5144(%ebp)      ## 8-byte Spill
	vmulsd	%xmm1, %xmm5, %xmm5
	vaddsd	%xmm0, %xmm5, %xmm1
	vmovsd	LCPI0_4-L0$pb(%esi), %xmm0 ## xmm0 = mem[0],zero
	vmovsd	%xmm0, -5120(%ebp)      ## 8-byte Spill
	vmulsd	%xmm0, %xmm6, %xmm6
	vcvtsi2sdl	-5112(%ebp), %xmm7, %xmm0 ## 4-byte Folded Reload
	vaddsd	%xmm1, %xmm6, %xmm1
	vmovsd	LCPI0_5-L0$pb(%esi), %xmm5 ## xmm5 = mem[0],zero
	vmulsd	%xmm5, %xmm0, %xmm0
	vaddsd	%xmm1, %xmm0, %xmm2
	vmovsd	LCPI0_6-L0$pb(%esi), %xmm6 ## xmm6 = mem[0],zero
	vmulsd	-5184(%ebp), %xmm6, %xmm0 ## 8-byte Folded Reload
	vcvtsi2sdl	%eax, %xmm7, %xmm1
	vaddsd	%xmm2, %xmm0, %xmm0
	vmovsd	%xmm0, -5112(%ebp)      ## 8-byte Spill
	vmulsd	%xmm7, %xmm1, %xmm0
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	%edx, %xmm7, %xmm1
	vaddsd	%xmm1, %xmm0, %xmm0
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	%ecx, %xmm7, %xmm1
	vmulsd	%xmm3, %xmm1, %xmm1
	vaddsd	%xmm0, %xmm1, %xmm0
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	-5156(%ebp), %xmm7, %xmm1 ## 4-byte Folded Reload
	movzbl	%bl, %eax
	movzbl	-5160(%ebp), %ecx       ## 1-byte Folded Reload
	vmulsd	%xmm4, %xmm1, %xmm1
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	-5172(%ebp), %xmm7, %xmm2 ## 4-byte Folded Reload
	movzbl	-5168(%ebp), %edx       ## 1-byte Folded Reload
	vaddsd	%xmm0, %xmm1, %xmm0
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	%eax, %xmm7, %xmm1
	vmulsd	-5144(%ebp), %xmm1, %xmm1 ## 8-byte Folded Reload
	vaddsd	%xmm0, %xmm1, %xmm0
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	%ecx, %xmm7, %xmm1
	vmulsd	-5120(%ebp), %xmm1, %xmm1 ## 8-byte Folded Reload
	vaddsd	%xmm0, %xmm1, %xmm0
	vxorps	%xmm7, %xmm7, %xmm7
	vcvtsi2sdl	%edx, %xmm7, %xmm1
	vmulsd	%xmm5, %xmm1, %xmm1
	vaddsd	%xmm0, %xmm1, %xmm0
	vmulsd	%xmm6, %xmm2, %xmm1
	vaddsd	%xmm0, %xmm1, %xmm0
	vmovsd	%xmm0, -5120(%ebp)      ## 8-byte Spill
	leal	-5048(%ebp), %ebx
	leal	-5088(%ebp), %edx
	movl	%ebx, %ecx
	calll	_uInt64_toAscii
	leal	-5080(%ebp), %edi
	leal	-5096(%ebp), %edx
	movl	%edi, %ecx
	calll	_uInt64_toAscii
	movl	L___stderrp$non_lazy_ptr-L0$pb(%esi), %eax
	movl	(%eax), %eax
	vmovsd	-5112(%ebp), %xmm2      ## 8-byte Reload
                                        ## xmm2 = mem[0],zero
	vmovsd	-5120(%ebp), %xmm3      ## 8-byte Reload
                                        ## xmm3 = mem[0],zero
	vdivsd	%xmm3, %xmm2, %xmm0
	vmulsd	LCPI0_7-L0$pb(%esi), %xmm3, %xmm1
	vdivsd	%xmm2, %xmm1, %xmm1
	vdivsd	%xmm2, %xmm3, %xmm2
	vmovsd	LCPI0_8-L0$pb(%esi), %xmm3 ## xmm3 = mem[0],zero
	vsubsd	%xmm2, %xmm3, %xmm2
	vmulsd	LCPI0_9-L0$pb(%esi), %xmm2, %xmm2
	subl	$48, %esp
	movl	%edi, 36(%esp)
	movl	%ebx, 32(%esp)
	leal	L_.str.2-L0$pb(%esi), %ecx
	movl	%ecx, 4(%esp)
	movl	%eax, (%esp)
	vmovsd	%xmm0, 8(%esp)
	vmovsd	%xmm1, 16(%esp)
	vmovsd	%xmm2, 24(%esp)
	calll	_fprintf
	addl	$48, %esp
	jmp	LBB0_23
LBB0_18:                                ## %if.then35
	movl	-5100(%ebp), %ecx       ## 4-byte Reload
	movl	L___stderrp$non_lazy_ptr-L0$pb(%ecx), %eax
	leal	L_.str.1-L0$pb(%ecx), %ecx
	pushl	(%eax)
	pushl	$1
	pushl	$21
	pushl	%ecx
	calll	_fwrite$UNIX2003
	addl	$16, %esp
LBB0_23:                                ## %cleanup
	movl	-5176(%ebp), %eax       ## 4-byte Reload
	movl	(%eax), %eax
	cmpl	-16(%ebp), %eax
	jne	LBB0_25
## BB#24:                               ## %cleanup
	addl	$5180, %esp             ## imm = 0x143C
	popl	%esi
	popl	%edi
	popl	%ebx
	popl	%ebp
	retl
LBB0_25:                                ## %cleanup
	calll	___stack_chk_fail
LBB0_9:                                 ## %errhandler
	subl	$4, %esp
	leal	-5124(%ebp), %eax
	leal	-5128(%ebp), %ecx
	leal	-5132(%ebp), %edx
	leal	-5136(%ebp), %edi
	leal	-5048(%ebp), %ebx
	pushl	%eax
	pushl	%ecx
	pushl	%edx
	pushl	%edi
	pushl	$1
	pushl	%esi
	pushl	%ebx
	calll	_BZ2_bzWriteClose64
	addl	$32, %esp
	movl	-5104(%ebp), %eax
	cmpl	$-3, %eax
	je	LBB0_19
## BB#10:                               ## %errhandler
	cmpl	$-6, %eax
	je	LBB0_20
## BB#11:                               ## %errhandler
	cmpl	$-9, %eax
	jne	LBB0_21
## BB#12:                               ## %sw.bb
	calll	_configError
LBB0_19:                                ## %sw.bb49
	calll	_outOfMemory
LBB0_20:                                ## %errhandler_io
	calll	_ioError
LBB0_21:                                ## %sw.default
	movl	-5100(%ebp), %eax       ## 4-byte Reload
	leal	L_.str.3-L0$pb(%eax), %ecx
	calll	_panic
                                        ## -- End function
	.section	__TEXT,__const
	.p2align	5               ## -- Begin function uInt64_toAscii
LCPI1_0:
	.byte	15                      ## 0xf
	.byte	14                      ## 0xe
	.byte	13                      ## 0xd
	.byte	12                      ## 0xc
	.byte	11                      ## 0xb
	.byte	10                      ## 0xa
	.byte	9                       ## 0x9
	.byte	8                       ## 0x8
	.byte	7                       ## 0x7
	.byte	6                       ## 0x6
	.byte	5                       ## 0x5
	.byte	4                       ## 0x4
	.byte	3                       ## 0x3
	.byte	2                       ## 0x2
	.byte	1                       ## 0x1
	.byte	0                       ## 0x0
	.byte	15                      ## 0xf
	.byte	14                      ## 0xe
	.byte	13                      ## 0xd
	.byte	12                      ## 0xc
	.byte	11                      ## 0xb
	.byte	10                      ## 0xa
	.byte	9                       ## 0x9
	.byte	8                       ## 0x8
	.byte	7                       ## 0x7
	.byte	6                       ## 0x6
	.byte	5                       ## 0x5
	.byte	4                       ## 0x4
	.byte	3                       ## 0x3
	.byte	2                       ## 0x2
	.byte	1                       ## 0x1
	.byte	0                       ## 0x0
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_uInt64_toAscii:                        ## @uInt64_toAscii
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%ebx
	pushl	%edi
	pushl	%esi
	subl	$108, %esp
	calll	L1$pb
L1$pb:
	popl	%eax
	movl	%eax, -88(%ebp)         ## 4-byte Spill
	movl	L___stack_chk_guard$non_lazy_ptr-L1$pb(%eax), %eax
	movl	%eax, -92(%ebp)         ## 4-byte Spill
	movl	(%eax), %eax
	movl	%eax, -16(%ebp)
	movl	(%edx), %eax
	movl	4(%edx), %ebx
	movl	%ebx, %edx
	shldl	$24, %eax, %edx
	movl	%edx, -72(%ebp)         ## 4-byte Spill
	movl	%ecx, -80(%ebp)         ## 4-byte Spill
	movl	%ebx, %esi
	shrl	$8, %esi
	movl	%ebx, %ecx
	shldl	$16, %eax, %ecx
	movl	%ecx, -68(%ebp)         ## 4-byte Spill
	movl	%ebx, %ecx
	shrl	$16, %ecx
	movl	%ecx, -64(%ebp)         ## 4-byte Spill
	movl	%ebx, %ecx
	movl	%eax, -76(%ebp)         ## 4-byte Spill
	shldl	$8, %eax, %ecx
	movl	%ebx, %edx
	shrl	$24, %edx
	movl	$0, -84(%ebp)           ## 4-byte Folded Spill
	leal	-48(%ebp), %eax
	movl	%eax, -96(%ebp)         ## 4-byte Spill
	movl	%esi, %eax
	jmp	LBB1_1
	.p2align	4, 0x90
LBB1_2:                                 ## %do.body.backedge
                                        ##   in Loop: Header=BB1_1 Depth=1
	incl	%edi
	movl	%edi, -84(%ebp)         ## 4-byte Spill
	incl	-96(%ebp)               ## 4-byte Folded Spill
	movl	-104(%ebp), %edx        ## 4-byte Reload
                                        ## kill: %DL<def> %DL<kill> %EDX<kill> %EDX<def>
LBB1_1:                                 ## %do.body
                                        ## =>This Inner Loop Header: Depth=1
	movzbl	-64(%ebp), %esi         ## 1-byte Folded Reload
	movzbl	%al, %eax
	movl	%eax, -52(%ebp)         ## 4-byte Spill
	movzbl	%bl, %eax
	movl	%eax, -56(%ebp)         ## 4-byte Spill
	movzbl	%cl, %ebx
	movzbl	%dl, %eax
	imull	$205, %eax, %eax
	andl	$63488, %eax            ## imm = 0xF800
	shrl	$11, %eax
	movl	%eax, -104(%ebp)        ## 4-byte Spill
                                        ## kill: %AL<def> %AL<kill> %EAX<kill>
	movb	$10, %cl
	mulb	%cl
	movl	%edx, -100(%ebp)        ## 4-byte Spill
	movl	%edx, %ecx
	subb	%al, %cl
	movzbl	%cl, %ecx
	shll	$8, %ecx
	movl	%esi, %eax
	orl	%ecx, %eax
	movl	%eax, -60(%ebp)         ## 4-byte Spill
	movzbl	-68(%ebp), %esi         ## 1-byte Folded Reload
	movl	$-858993459, %ecx       ## imm = 0xCCCCCCCD
	mull	%ecx
	movl	%edx, %ecx
	movzbl	-72(%ebp), %edi         ## 1-byte Folded Reload
	movl	%ecx, %eax
	shrl	$3, %eax
	movl	%eax, -64(%ebp)         ## 4-byte Spill
	leal	(%eax,%eax), %eax
	leal	(%eax,%eax,4), %eax
	movl	-60(%ebp), %edx         ## 4-byte Reload
	subl	%eax, %edx
	shll	$8, %edx
	movl	-52(%ebp), %eax         ## 4-byte Reload
	orl	%edx, %eax
	movl	%eax, -52(%ebp)         ## 4-byte Spill
	movl	$-858993459, %edx       ## imm = 0xCCCCCCCD
	mull	%edx
	orl	%edx, %ecx
	shrl	$3, %edx
	movl	%edx, -60(%ebp)         ## 4-byte Spill
	leal	(%edx,%edx), %eax
	leal	(%eax,%eax,4), %eax
	movl	-52(%ebp), %edx         ## 4-byte Reload
	subl	%eax, %edx
	shll	$8, %edx
	movl	-56(%ebp), %eax         ## 4-byte Reload
	orl	%edx, %eax
	movl	%eax, -56(%ebp)         ## 4-byte Spill
	movl	$-858993459, %edx       ## imm = 0xCCCCCCCD
	mull	%edx
	movl	%edx, -116(%ebp)        ## 4-byte Spill
	shrl	$3, %edx
	movl	%edx, -112(%ebp)        ## 4-byte Spill
	leal	(%edx,%edx), %eax
	leal	(%eax,%eax,4), %eax
	movl	-56(%ebp), %edx         ## 4-byte Reload
	subl	%eax, %edx
	shll	$8, %edx
	orl	%edx, %ebx
	movl	%ebx, %eax
	movl	$-858993459, %edx       ## imm = 0xCCCCCCCD
	mull	%edx
	movl	%edx, -56(%ebp)         ## 4-byte Spill
	movl	%edx, %eax
	shrl	$3, %eax
	movl	%eax, -52(%ebp)         ## 4-byte Spill
	leal	(%eax,%eax), %eax
	leal	(%eax,%eax,4), %eax
	subl	%eax, %ebx
	shll	$8, %ebx
	orl	%ebx, %esi
	movl	%esi, %eax
	movl	$-858993459, %ebx       ## imm = 0xCCCCCCCD
	mull	%ebx
	movl	%edx, -108(%ebp)        ## 4-byte Spill
	movl	%edx, %eax
	shrl	$3, %eax
	movl	%eax, -68(%ebp)         ## 4-byte Spill
	leal	(%eax,%eax), %eax
	leal	(%eax,%eax,4), %eax
	subl	%eax, %esi
	shll	$8, %esi
	orl	%esi, %edi
	movl	%edi, %eax
	mull	%ebx
	movl	%edx, %esi
	movl	%esi, %eax
	shrl	$3, %eax
	movl	%eax, -72(%ebp)         ## 4-byte Spill
	leal	(%eax,%eax), %eax
	leal	(%eax,%eax,4), %eax
	subl	%eax, %edi
	shll	$8, %edi
	movzbl	-76(%ebp), %ebx         ## 1-byte Folded Reload
	orl	%edi, %ebx
	movl	%ebx, %eax
	movl	$-858993459, %edx       ## imm = 0xCCCCCCCD
	mull	%edx
	movl	%edx, %eax
	shrl	$3, %eax
	movl	%eax, -76(%ebp)         ## 4-byte Spill
	leal	(%eax,%eax), %eax
	leal	(%eax,%eax,4), %eax
	subl	%eax, %ebx
	orb	$48, %bl
	movl	-84(%ebp), %eax         ## 4-byte Reload
	movb	%bl, -48(%ebp,%eax)
	movl	-112(%ebp), %ebx        ## 4-byte Reload
	orl	-116(%ebp), %ecx        ## 4-byte Folded Reload
	orl	-56(%ebp), %ecx         ## 4-byte Folded Reload
	orl	-108(%ebp), %ecx        ## 4-byte Folded Reload
	orl	%esi, %ecx
	orl	%edx, %ecx
	shrl	$3, %ecx
	testb	%cl, %cl
	movl	-52(%ebp), %ecx         ## 4-byte Reload
	movl	%eax, %edi
	movl	-60(%ebp), %eax         ## 4-byte Reload
	jne	LBB1_2
## BB#3:                                ## %uInt64_isZero.exit
                                        ##   in Loop: Header=BB1_1 Depth=1
	movl	$0, -64(%ebp)           ## 4-byte Folded Spill
	movl	$0, %eax
	movl	$0, %ebx
	cmpb	$9, -100(%ebp)          ## 1-byte Folded Reload
	movl	$0, %ecx
	movl	$0, -68(%ebp)           ## 4-byte Folded Spill
	movl	$0, -72(%ebp)           ## 4-byte Folded Spill
	movl	$0, -76(%ebp)           ## 4-byte Folded Spill
	ja	LBB1_2
## BB#4:                                ## %do.end
	movl	-80(%ebp), %esi         ## 4-byte Reload
	movb	$0, 1(%esi,%edi)
	testl	%edi, %edi
	js	LBB1_11
## BB#5:                                ## %for.body.lr.ph
	leal	1(%edi), %ecx
	xorl	%eax, %eax
	cmpl	$128, %ecx
	jb	LBB1_9
## BB#6:                                ## %vector.ph
	movl	%ecx, -52(%ebp)         ## 4-byte Spill
	movl	%ecx, %eax
	andl	$-128, %eax
	leal	96(%esi), %edx
	movl	%eax, %esi
	negl	%esi
	movl	-88(%ebp), %ecx         ## 4-byte Reload
	vmovdqa	LCPI1_0-L1$pb(%ecx), %ymm0 ## ymm0 = [15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0]
	movl	%edi, %ecx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB1_7:                                 ## %vector.body
                                        ## =>This Inner Loop Header: Depth=1
	leal	-48(%ebp,%edi), %ebx
	vmovdqu	-31(%ecx,%ebx), %ymm1
	vpshufb	%ymm0, %ymm1, %ymm1
	vperm2i128	$1, %ymm0, %ymm1, %ymm1 ## ymm1 = ymm1[2,3,0,1]
	vmovdqu	-63(%ecx,%ebx), %ymm2
	vpshufb	%ymm0, %ymm2, %ymm2
	vperm2i128	$1, %ymm0, %ymm2, %ymm2 ## ymm2 = ymm2[2,3,0,1]
	vmovdqu	-127(%ecx,%ebx), %ymm3
	vmovdqu	-95(%ecx,%ebx), %ymm4
	vpshufb	%ymm0, %ymm4, %ymm4
	vperm2i128	$1, %ymm0, %ymm4, %ymm4 ## ymm4 = ymm4[2,3,0,1]
	vpshufb	%ymm0, %ymm3, %ymm3
	vperm2i128	$1, %ymm0, %ymm3, %ymm3 ## ymm3 = ymm3[2,3,0,1]
	vmovdqu	%ymm1, -96(%edx)
	vmovdqu	%ymm2, -64(%edx)
	vmovdqu	%ymm4, -32(%edx)
	vmovdqu	%ymm3, (%edx)
	addl	$-128, %edi
	subl	$-128, %edx
	cmpl	%edi, %esi
	jne	LBB1_7
## BB#8:                                ## %middle.block
	cmpl	%eax, -52(%ebp)         ## 4-byte Folded Reload
	movl	-80(%ebp), %esi         ## 4-byte Reload
	movl	%ecx, %edi
	je	LBB1_11
LBB1_9:                                 ## %for.body.preheader
	leal	-48(%ebp), %ecx
	subl	%eax, %ecx
	addl	%edi, %ecx
	.p2align	4, 0x90
LBB1_10:                                ## %for.body
                                        ## =>This Inner Loop Header: Depth=1
	movzbl	(%ecx), %edx
	movb	%dl, (%esi,%eax)
	decl	%ecx
	cmpl	%edi, %eax
	leal	1(%eax), %eax
	jne	LBB1_10
LBB1_11:                                ## %for.end
	movl	-92(%ebp), %eax         ## 4-byte Reload
	movl	(%eax), %eax
	cmpl	-16(%ebp), %eax
	jne	LBB1_13
## BB#12:                               ## %for.end
	addl	$108, %esp
	popl	%esi
	popl	%edi
	popl	%ebx
	popl	%ebp
	vzeroupper
	retl
LBB1_13:                                ## %for.end
	vzeroupper
	calll	___stack_chk_fail
                                        ## -- End function
	.p2align	4, 0x90         ## -- Begin function configError
_configError:                           ## @configError
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%esi
	pushl	%eax
	calll	L2$pb
L2$pb:
	popl	%esi
	movl	L___stderrp$non_lazy_ptr-L2$pb(%esi), %eax
	leal	L_.str.17-L2$pb(%esi), %ecx
	pushl	(%eax)
	pushl	$1
	pushl	$235
	pushl	%ecx
	calll	_fwrite$UNIX2003
	addl	$16, %esp
	movl	L_exitValue$non_lazy_ptr-L2$pb(%esi), %eax
	movl	$0, (%eax)
	subl	$12, %esp
	pushl	$0
	calll	_exit
	addl	$12, %esp
                                        ## -- End function
	.p2align	4, 0x90         ## -- Begin function outOfMemory
_outOfMemory:                           ## @outOfMemory
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	subl	$8, %esp
	calll	L3$pb
L3$pb:
	popl	%eax
	movl	L___stderrp$non_lazy_ptr-L3$pb(%eax), %ecx
	movl	L_progName$non_lazy_ptr-L3$pb(%eax), %edx
	subl	$4, %esp
	leal	L_.str.16-L3$pb(%eax), %eax
	pushl	(%edx)
	pushl	%eax
	pushl	(%ecx)
	calll	_fprintf
	addl	$16, %esp
	calll	_showFileNames
	calll	_cleanUpAndFail
                                        ## -- End function
	.p2align	4, 0x90         ## -- Begin function ioError
_ioError:                               ## @ioError
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%esi
	pushl	%eax
	calll	L4$pb
L4$pb:
	popl	%eax
	movl	L___stderrp$non_lazy_ptr-L4$pb(%eax), %ecx
	movl	L_progName$non_lazy_ptr-L4$pb(%eax), %esi
	subl	$4, %esp
	leal	L_.str.15-L4$pb(%eax), %eax
	pushl	(%esi)
	pushl	%eax
	pushl	(%ecx)
	calll	_fprintf
	addl	$4, %esp
	pushl	(%esi)
	calll	_perror
	addl	$16, %esp
	calll	_showFileNames
	calll	_cleanUpAndFail
                                        ## -- End function
	.p2align	4, 0x90         ## -- Begin function panic
_panic:                                 ## @panic
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%esi
	pushl	%eax
	calll	L5$pb
L5$pb:
	popl	%eax
	movl	L___stderrp$non_lazy_ptr-L5$pb(%eax), %edx
	movl	L_progName$non_lazy_ptr-L5$pb(%eax), %esi
	leal	L_.str.10-L5$pb(%eax), %eax
	pushl	%ecx
	pushl	(%esi)
	pushl	%eax
	pushl	(%edx)
	calll	_fprintf
	addl	$16, %esp
	calll	_showFileNames
	calll	_cleanUpAndFail
                                        ## -- End function
	.globl	_uncompressStream       ## -- Begin function uncompressStream
	.p2align	4, 0x90
_uncompressStream:                      ## @uncompressStream
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%ebx
	pushl	%edi
	pushl	%esi
	subl	$10060, %esp            ## imm = 0x274C
	calll	L6$pb
L6$pb:
	popl	%ebx
	movl	L___stack_chk_guard$non_lazy_ptr-L6$pb(%ebx), %eax
	movl	%eax, -10032(%ebp)      ## 4-byte Spill
	movl	(%eax), %eax
	movl	%eax, -16(%ebp)
	movl	$0, -10040(%ebp)
	movl	L_verbosity$non_lazy_ptr-L6$pb(%ebx), %edi
	movl	L_smallMode$non_lazy_ptr-L6$pb(%ebx), %eax
	movl	%eax, -10052(%ebp)      ## 4-byte Spill
	movzbl	(%eax), %eax
	subl	$8, %esp
	leal	-10016(%ebp), %ecx
	leal	-10020(%ebp), %edx
	pushl	$0
	pushl	%ecx
	pushl	%eax
	pushl	(%edi)
	pushl	8(%ebp)
	pushl	%edx
	calll	_BZ2_bzReadOpen
	addl	$32, %esp
	movl	%eax, %esi
	xorl	%ecx, %ecx
	testl	%esi, %esi
	je	LBB6_40
## BB#1:                                ## %entry
	movl	-10020(%ebp), %eax
	testl	%eax, %eax
	jne	LBB6_40
## BB#2:                                ## %if.end.preheader
	movl	%edi, -10044(%ebp)      ## 4-byte Spill
	xorl	%ecx, %ecx
	leal	-5016(%ebp), %edi
LBB6_3:                                 ## %if.end
                                        ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB6_5 Depth 2
                                        ##     Child Loop BB6_17 Depth 2
                                        ##     Child Loop BB6_22 Depth 2
	incl	%ecx
	movl	%ecx, -10036(%ebp)      ## 4-byte Spill
	xorl	%ecx, %ecx
	jmp	LBB6_5
	.p2align	4, 0x90
LBB6_4:                                 ## %if.then21
                                        ##   in Loop: Header=BB6_5 Depth=2
	pushl	12(%ebp)
	pushl	%eax
	pushl	$1
	pushl	%edi
	calll	_spec_fwrite
	addl	$16, %esp
	movl	-10020(%ebp), %ecx
LBB6_5:                                 ## %while.cond4
                                        ##   Parent Loop BB6_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	testl	%ecx, %ecx
	jne	LBB6_9
## BB#6:                                ## %while.body7
                                        ##   in Loop: Header=BB6_5 Depth=2
	pushl	$5000                   ## imm = 0x1388
	pushl	%edi
	pushl	%esi
	leal	-10020(%ebp), %eax
	pushl	%eax
	calll	_BZ2_bzRead
	addl	$16, %esp
	movl	-10020(%ebp), %ecx
	cmpl	$-5, %ecx
	je	LBB6_29
## BB#7:                                ## %if.end13
                                        ##   in Loop: Header=BB6_5 Depth=2
	testl	%eax, %eax
	jle	LBB6_5
## BB#8:                                ## %if.end13
                                        ##   in Loop: Header=BB6_5 Depth=2
	movl	%ecx, %edx
	orl	$4, %edx
	cmpl	$4, %edx
	je	LBB6_4
	jmp	LBB6_5
	.p2align	4, 0x90
LBB6_9:                                 ## %while.cond4
                                        ##   in Loop: Header=BB6_3 Depth=1
	cmpl	$4, %ecx
	jne	LBB6_39
## BB#10:                               ## %if.end28
                                        ##   in Loop: Header=BB6_3 Depth=1
	leal	-10040(%ebp), %eax
	pushl	%eax
	leal	-10056(%ebp), %eax
	pushl	%eax
	pushl	%esi
	leal	-10020(%ebp), %eax
	pushl	%eax
	calll	_BZ2_bzReadGetUnused
	addl	$16, %esp
	cmpl	$0, -10020(%ebp)
	jne	LBB6_63
## BB#11:                               ## %if.end32
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10040(%ebp), %eax
	testl	%eax, %eax
	jle	LBB6_23
## BB#12:                               ## %for.body.lr.ph
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10056(%ebp), %ecx
	xorl	%edx, %edx
	cmpl	$128, %eax
	movl	%eax, -10024(%ebp)      ## 4-byte Spill
	jb	LBB6_22
## BB#13:                               ## %vector.memcheck
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10024(%ebp), %eax      ## 4-byte Reload
	leal	(%ecx,%eax), %eax
	movl	%ebx, -10028(%ebp)      ## 4-byte Spill
	leal	-10016(%ebp), %ebx
	cmpl	%eax, %ebx
	movl	-10024(%ebp), %eax      ## 4-byte Reload
	movl	-10028(%ebp), %ebx      ## 4-byte Reload
	jae	LBB6_15
## BB#14:                               ## %vector.memcheck
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10024(%ebp), %eax      ## 4-byte Reload
	leal	-10016(%ebp,%eax), %eax
	cmpl	%eax, %ecx
	movl	-10024(%ebp), %eax      ## 4-byte Reload
	jb	LBB6_22
LBB6_15:                                ## %vector.ph
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	%eax, %edx
	andl	$-128, %edx
	leal	-128(%edx), %ebx
	shrl	$7, %ebx
	leal	1(%ebx), %eax
	andl	$1, %eax
	testl	%ebx, %ebx
	movl	%eax, -10048(%ebp)      ## 4-byte Spill
	je	LBB6_18
## BB#16:                               ## %vector.ph.new
                                        ##   in Loop: Header=BB6_3 Depth=1
	decl	%eax
	subl	%ebx, %eax
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB6_17:                                ## %vector.body
                                        ##   Parent Loop BB6_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	vmovups	(%ecx,%ebx), %ymm0
	vmovups	32(%ecx,%ebx), %ymm1
	vmovups	64(%ecx,%ebx), %ymm2
	vmovups	96(%ecx,%ebx), %ymm3
	vmovups	%ymm0, -10016(%ebp,%ebx)
	vmovups	%ymm1, -9984(%ebp,%ebx)
	vmovups	%ymm2, -9952(%ebp,%ebx)
	vmovups	%ymm3, -9920(%ebp,%ebx)
	vmovups	128(%ecx,%ebx), %ymm0
	vmovups	160(%ecx,%ebx), %ymm1
	vmovups	192(%ecx,%ebx), %ymm2
	vmovups	224(%ecx,%ebx), %ymm3
	vmovups	%ymm0, -9888(%ebp,%ebx)
	vmovups	%ymm1, -9856(%ebp,%ebx)
	vmovups	%ymm2, -9824(%ebp,%ebx)
	vmovups	%ymm3, -9792(%ebp,%ebx)
	addl	$256, %ebx              ## imm = 0x100
	addl	$2, %eax
	jne	LBB6_17
	jmp	LBB6_19
LBB6_18:                                ##   in Loop: Header=BB6_3 Depth=1
	xorl	%ebx, %ebx
LBB6_19:                                ## %middle.block.unr-lcssa
                                        ##   in Loop: Header=BB6_3 Depth=1
	cmpl	$0, -10048(%ebp)        ## 4-byte Folded Reload
	je	LBB6_21
## BB#20:                               ## %vector.body.epil
                                        ##   in Loop: Header=BB6_3 Depth=1
	vmovups	(%ecx,%ebx), %ymm0
	vmovups	32(%ecx,%ebx), %ymm1
	vmovups	64(%ecx,%ebx), %ymm2
	vmovups	96(%ecx,%ebx), %ymm3
	vmovups	%ymm0, -10016(%ebp,%ebx)
	vmovups	%ymm1, -9984(%ebp,%ebx)
	vmovups	%ymm2, -9952(%ebp,%ebx)
	vmovups	%ymm3, -9920(%ebp,%ebx)
LBB6_21:                                ## %middle.block
                                        ##   in Loop: Header=BB6_3 Depth=1
	cmpl	%edx, -10024(%ebp)      ## 4-byte Folded Reload
	movl	-10028(%ebp), %ebx      ## 4-byte Reload
	je	LBB6_23
	.p2align	4, 0x90
LBB6_22:                                ## %for.body
                                        ##   Parent Loop BB6_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movzbl	(%ecx,%edx), %eax
	movb	%al, -10016(%ebp,%edx)
	incl	%edx
	cmpl	-10024(%ebp), %edx      ## 4-byte Folded Reload
	jl	LBB6_22
LBB6_23:                                ## %for.end
                                        ##   in Loop: Header=BB6_3 Depth=1
	subl	$8, %esp
	pushl	%esi
	leal	-10020(%ebp), %eax
	pushl	%eax
	vzeroupper
	calll	_BZ2_bzReadClose
	addl	$16, %esp
	cmpl	$0, -10020(%ebp)
	jne	LBB6_63
## BB#24:                               ## %if.end40
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10040(%ebp), %eax
	testl	%eax, %eax
	movl	8(%ebp), %esi
	jne	LBB6_27
## BB#25:                               ## %land.lhs.true43
                                        ##   in Loop: Header=BB6_3 Depth=1
	subl	$12, %esp
	pushl	%esi
	calll	_spec_getc
	addl	$16, %esp
	cmpl	$-1, %eax
	je	LBB6_35
## BB#26:                               ## %myfeof.exit.thread
                                        ##   in Loop: Header=BB6_3 Depth=1
	subl	$8, %esp
	movzbl	%al, %eax
	pushl	%esi
	pushl	%eax
	calll	_spec_ungetc
	addl	$16, %esp
	movl	-10040(%ebp), %eax
LBB6_27:                                ## %if.end47
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10052(%ebp), %ecx      ## 4-byte Reload
	movzbl	(%ecx), %ecx
	subl	$8, %esp
	pushl	%eax
	leal	-10016(%ebp), %eax
	pushl	%eax
	pushl	%ecx
	movl	-10044(%ebp), %eax      ## 4-byte Reload
	pushl	(%eax)
	pushl	%esi
	leal	-10020(%ebp), %eax
	pushl	%eax
	calll	_BZ2_bzReadOpen
	addl	$32, %esp
	movl	%eax, %esi
	testl	%esi, %esi
	je	LBB6_39
## BB#28:                               ## %if.end47
                                        ##   in Loop: Header=BB6_3 Depth=1
	movl	-10020(%ebp), %eax
	testl	%eax, %eax
	movl	-10036(%ebp), %ecx      ## 4-byte Reload
	je	LBB6_3
	jmp	LBB6_40
LBB6_29:                                ## %trycat
	movl	L_forceOverwrite$non_lazy_ptr-L6$pb(%ebx), %eax
	cmpb	$0, (%eax)
	movl	-10036(%ebp), %ecx      ## 4-byte Reload
	je	LBB6_40
## BB#30:                               ## %if.then71
	subl	$12, %esp
	movl	8(%ebp), %esi
	pushl	%esi
	calll	_spec_rewind
	addl	$4, %esp
	jmp	LBB6_32
	.p2align	4, 0x90
LBB6_31:                                ## %if.end86
                                        ##   in Loop: Header=BB6_32 Depth=1
	subl	$12, %esp
LBB6_32:                                ## %if.end86
                                        ## =>This Inner Loop Header: Depth=1
	pushl	%esi
	calll	_spec_getc
	addl	$16, %esp
	cmpl	$-1, %eax
	je	LBB6_35
## BB#33:                               ## %if.end78
                                        ##   in Loop: Header=BB6_32 Depth=1
	subl	$8, %esp
	movzbl	%al, %eax
	pushl	%esi
	pushl	%eax
	calll	_spec_ungetc
	addl	$16, %esp
	pushl	%esi
	pushl	$5000                   ## imm = 0x1388
	pushl	$1
	pushl	%edi
	calll	_spec_fread
	addl	$16, %esp
	testl	%eax, %eax
	jle	LBB6_31
## BB#34:                               ## %if.then83
                                        ##   in Loop: Header=BB6_32 Depth=1
	pushl	12(%ebp)
	pushl	%eax
	pushl	$1
	pushl	%edi
	calll	_spec_fwrite
	addl	$16, %esp
	jmp	LBB6_31
LBB6_35:                                ## %if.end56
	cmpl	$1, 12(%ebp)
	je	LBB6_37
## BB#36:                               ## %if.then59
	movl	L_outputHandleJustInCase$non_lazy_ptr-L6$pb(%ebx), %eax
	movl	$0, (%eax)
LBB6_37:                                ## %if.end64
	movl	L_outputHandleJustInCase$non_lazy_ptr-L6$pb(%ebx), %eax
	movl	$0, (%eax)
	movl	%ebx, %ecx
	movb	$1, %bl
	movl	-10044(%ebp), %eax      ## 4-byte Reload
	cmpl	$2, (%eax)
	jl	LBB6_47
## BB#38:                               ## %if.then67
	movl	L___stderrp$non_lazy_ptr-L6$pb(%ecx), %eax
	leal	L_.str.6-L6$pb(%ecx), %ecx
	pushl	(%eax)
	pushl	$1
	pushl	$5
	pushl	%ecx
	calll	_fwrite$UNIX2003
	jmp	LBB6_46
LBB6_39:                                ## %errhandler.loopexit
	movl	-10036(%ebp), %ecx      ## 4-byte Reload
LBB6_40:                                ## %errhandler
	movl	%ecx, %edi
	subl	$8, %esp
	leal	-10060(%ebp), %eax
	pushl	%esi
	pushl	%eax
	calll	_BZ2_bzReadClose
	addl	$16, %esp
	movl	-10020(%ebp), %eax
	addl	$9, %eax
	cmpl	$6, %eax
	ja	LBB6_50
## BB#41:                               ## %errhandler
Ltmp0 = LJTI6_0-L6$pb
	movl	Ltmp0(%ebx,%eax,4), %eax
	addl	%ebx, %eax
	jmpl	*%eax
LBB6_42:                                ## %sw.bb93
	cmpl	$1, %edi
	jne	LBB6_44
## BB#43:
	xorl	%ebx, %ebx
	jmp	LBB6_47
LBB6_44:                                ## %if.else
	movl	L_noisy$non_lazy_ptr-L6$pb(%ebx), %eax
	movl	%ebx, %esi
	movb	$1, %bl
	cmpb	$0, (%eax)
	je	LBB6_47
## BB#45:                               ## %if.then106
	movl	L___stderrp$non_lazy_ptr-L6$pb(%esi), %eax
	movl	(%eax), %eax
	movl	L_progName$non_lazy_ptr-L6$pb(%esi), %ecx
	movl	(%ecx), %ecx
	subl	$16, %esp
	movl	L_inName$non_lazy_ptr-L6$pb(%esi), %edx
	movl	%edx, 12(%esp)
	movl	%ecx, 8(%esp)
	leal	L_.str.7-L6$pb(%esi), %ecx
	movl	%ecx, 4(%esp)
	movl	%eax, (%esp)
	calll	_fprintf
LBB6_46:                                ## %cleanup
	addl	$16, %esp
LBB6_47:                                ## %cleanup
	movl	-10032(%ebp), %eax      ## 4-byte Reload
	movl	(%eax), %eax
	cmpl	-16(%ebp), %eax
	jne	LBB6_49
## BB#48:                               ## %cleanup
	movzbl	%bl, %eax
	addl	$10060, %esp            ## imm = 0x274C
	popl	%esi
	popl	%edi
	popl	%ebx
	popl	%ebp
	retl
LBB6_49:                                ## %cleanup
	calll	___stack_chk_fail
LBB6_50:                                ## %sw.default
	leal	L_.str.8-L6$pb(%ebx), %ecx
	calll	_panic
LBB6_51:                                ## %sw.bb
	calll	_configError
LBB6_52:                                ## %sw.bb92
	movl	%ebx, %esi
	movl	L_noisy$non_lazy_ptr-L6$pb(%ebx), %edi
	cmpb	$0, (%edi)
	je	LBB6_61
## BB#53:                               ## %if.then.i
	movl	%esi, %eax
	movl	L___stderrp$non_lazy_ptr-L6$pb(%eax), %ecx
	movl	L_progName$non_lazy_ptr-L6$pb(%eax), %ebx
	subl	$4, %esp
	leal	L_.str.14-L6$pb(%eax), %eax
	pushl	(%ebx)
	pushl	%eax
	movl	%ecx, -10024(%ebp)      ## 4-byte Spill
	pushl	(%ecx)
	calll	_fprintf
	addl	$4, %esp
	pushl	(%ebx)
	calll	_perror
	addl	$16, %esp
	cmpb	$0, (%edi)
	je	LBB6_61
## BB#54:                               ## %showFileNames.exit.i
	movl	-10024(%ebp), %eax      ## 4-byte Reload
	movl	(%eax), %eax
	subl	$16, %esp
	movl	%esi, %edx
	movl	L_outName$non_lazy_ptr-L6$pb(%edx), %ecx
	movl	%ecx, 12(%esp)
	movl	L_inName$non_lazy_ptr-L6$pb(%edx), %ecx
	movl	%ecx, 8(%esp)
	leal	L_.str.11-L6$pb(%edx), %ecx
	movl	%ecx, 4(%esp)
	movl	%eax, (%esp)
	calll	_fprintf
	addl	$16, %esp
	cmpb	$0, (%edi)
	je	LBB6_61
## BB#55:                               ## %if.then.i2.i
	leal	L_.str.13-L6$pb(%esi), %eax
	movl	-10024(%ebp), %ecx      ## 4-byte Reload
	pushl	(%ecx)
	jmp	LBB6_60
LBB6_56:                                ## %errhandler_io
	calll	_ioError
LBB6_57:                                ## %sw.bb90
	movl	L___stderrp$non_lazy_ptr-L6$pb(%ebx), %esi
	movl	L_progName$non_lazy_ptr-L6$pb(%ebx), %eax
	subl	$4, %esp
	leal	L_.str.12-L6$pb(%ebx), %ecx
	pushl	(%eax)
	pushl	%ecx
	pushl	(%esi)
	calll	_fprintf
	addl	$16, %esp
	movl	%ebx, -10028(%ebp)      ## 4-byte Spill
	movl	L_noisy$non_lazy_ptr-L6$pb(%ebx), %edi
	cmpb	$0, (%edi)
	je	LBB6_61
## BB#58:                               ## %showFileNames.exit
	movl	(%esi), %eax
	subl	$16, %esp
	movl	-10028(%ebp), %edx      ## 4-byte Reload
	movl	L_outName$non_lazy_ptr-L6$pb(%edx), %ecx
	movl	%ecx, 12(%esp)
	movl	L_inName$non_lazy_ptr-L6$pb(%edx), %ecx
	movl	%ecx, 8(%esp)
	leal	L_.str.11-L6$pb(%edx), %ecx
	movl	%ecx, 4(%esp)
	movl	%eax, (%esp)
	calll	_fprintf
	addl	$16, %esp
	cmpb	$0, (%edi)
	je	LBB6_61
## BB#59:                               ## %if.then.i160
	movl	-10028(%ebp), %eax      ## 4-byte Reload
	leal	L_.str.13-L6$pb(%eax), %eax
	pushl	(%esi)
LBB6_60:                                ## %cadvise.exit
	pushl	$1
	pushl	$240
	pushl	%eax
	calll	_fwrite$UNIX2003
	addl	$16, %esp
LBB6_61:                                ## %cadvise.exit
	calll	_cleanUpAndFail
LBB6_62:                                ## %sw.bb91
	calll	_outOfMemory
LBB6_63:                                ## %if.then31
	leal	L_.str.5-L6$pb(%ebx), %ecx
	calll	_panic
	.p2align	2, 0x90
	.data_region jt32
L6_0_set_51 = LBB6_51-L6$pb
L6_0_set_50 = LBB6_50-L6$pb
L6_0_set_52 = LBB6_52-L6$pb
L6_0_set_56 = LBB6_56-L6$pb
L6_0_set_42 = LBB6_42-L6$pb
L6_0_set_57 = LBB6_57-L6$pb
L6_0_set_62 = LBB6_62-L6$pb
LJTI6_0:
	.long	L6_0_set_51
	.long	L6_0_set_50
	.long	L6_0_set_52
	.long	L6_0_set_56
	.long	L6_0_set_42
	.long	L6_0_set_57
	.long	L6_0_set_62
	.end_data_region
                                        ## -- End function
	.p2align	4, 0x90         ## -- Begin function showFileNames
_showFileNames:                         ## @showFileNames
## BB#0:                                ## %entry
	calll	L7$pb
L7$pb:
	popl	%eax
	movl	L_noisy$non_lazy_ptr-L7$pb(%eax), %ecx
	cmpb	$0, (%ecx)
	je	LBB7_2
## BB#1:                                ## %if.then
	pushl	%ebp
	movl	%esp, %ebp
	subl	$24, %esp
	movl	L___stderrp$non_lazy_ptr-L7$pb(%eax), %ecx
	movl	(%ecx), %ecx
	movl	L_outName$non_lazy_ptr-L7$pb(%eax), %edx
	movl	%edx, 12(%esp)
	movl	L_inName$non_lazy_ptr-L7$pb(%eax), %edx
	movl	%edx, 8(%esp)
	leal	L_.str.11-L7$pb(%eax), %eax
	movl	%eax, 4(%esp)
	movl	%ecx, (%esp)
	calll	_fprintf
	addl	$24, %esp
	popl	%ebp
LBB7_2:                                 ## %if.end
	retl
                                        ## -- End function
	.p2align	4, 0x90         ## -- Begin function cleanUpAndFail
_cleanUpAndFail:                        ## @cleanUpAndFail
## BB#0:                                ## %entry
	pushl	%ebp
	movl	%esp, %ebp
	subl	$8, %esp
	calll	L8$pb
L8$pb:
	popl	%eax
	movl	L_exitValue$non_lazy_ptr-L8$pb(%eax), %eax
	movl	$0, (%eax)
	movl	$0, (%esp)
	calll	_exit
	subl	$4, %esp
                                        ## -- End function
	.comm	_blockSize100k,4,2      ## @blockSize100k
	.comm	_verbosity,4,2          ## @verbosity
	.comm	_workFactor,4,2         ## @workFactor
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"\n"

	.comm	_outputHandleJustInCase,4,2 ## @outputHandleJustInCase
L_.str.1:                               ## @.str.1
	.asciz	" no data compressed.\n"

L_.str.2:                               ## @.str.2
	.asciz	"%6.3f:1, %6.3f bits/byte, %5.2f%% saved, %s in, %s out.\n"

L_.str.3:                               ## @.str.3
	.asciz	"compress:unexpected error"

	.comm	_smallMode,1,0          ## @smallMode
L_.str.5:                               ## @.str.5
	.asciz	"decompress:bzReadGetUnused"

L_.str.6:                               ## @.str.6
	.asciz	"\n    "

	.comm	_forceOverwrite,1,0     ## @forceOverwrite
	.comm	_noisy,1,0              ## @noisy
L_.str.7:                               ## @.str.7
	.asciz	"\n%s: %s: trailing garbage after EOF ignored\n"

	.comm	_progName,4,2           ## @progName
	.comm	_inName,1034,0          ## @inName
L_.str.8:                               ## @.str.8
	.asciz	"decompress:unexpected error"

	.comm	_keepInputFiles,1,0     ## @keepInputFiles
	.comm	_deleteOutputOnInterrupt,1,0 ## @deleteOutputOnInterrupt
	.comm	_testFailsExist,1,0     ## @testFailsExist
	.comm	_unzFailsExist,1,0      ## @unzFailsExist
	.comm	_numFileNames,4,2       ## @numFileNames
	.comm	_numFilesProcessed,4,2  ## @numFilesProcessed
	.comm	_exitValue,4,2          ## @exitValue
	.comm	_opMode,4,2             ## @opMode
	.comm	_srcMode,4,2            ## @srcMode
	.comm	_longestFileName,4,2    ## @longestFileName
	.comm	_outName,1034,0         ## @outName
	.comm	_tmpName,1034,0         ## @tmpName
	.comm	_progNameReally,1034,0  ## @progNameReally
L_.str.10:                              ## @.str.10
	.asciz	"\n%s: PANIC -- internal consistency error:\n\t%s\n\tThis is probably a BUG, but it may be in your COMPILER.  Please do not bother\n\tthe original author.\n"

L_.str.11:                              ## @.str.11
	.asciz	"\tInput file = %s, output file = %s\n"

L_.str.12:                              ## @.str.12
	.asciz	"\n%s: Data integrity error when decompressing.\n"

L_.str.13:                              ## @.str.13
	.asciz	"\nIt is possible that the compressed file(s) have become corrupted.\nYou can use the -tvv option to test integrity of such files.\n\nYou can use the `bzip2recover' program to attempt to recover\ndata from undamaged sections of corrupted files.\n\n"

L_.str.14:                              ## @.str.14
	.asciz	"\n%s: Compressed file ends unexpectedly;\n\tperhaps it is corrupted?  *Possible* reason follows.\n"

L_.str.15:                              ## @.str.15
	.asciz	"\n%s: I/O or other error, bailing out.  Possible reason follows.\n"

L_.str.16:                              ## @.str.16
	.asciz	"\n%s: couldn't allocate enough memory\n"

L_.str.17:                              ## @.str.17
	.asciz	"bzip2: I'm not configured correctly for this platform!\n\tI require Int32, Int16 and Char to have sizes\n\tof 4, 2 and 1 bytes to run properly, and they don't.\n\tProbably you can fix this by defining them correctly,\n\tand recompiling.  Bye!\n"


	.section	__IMPORT,__pointers,non_lazy_symbol_pointers
L___stack_chk_guard$non_lazy_ptr:
	.indirect_symbol	___stack_chk_guard
	.long	0
L___stderrp$non_lazy_ptr:
	.indirect_symbol	___stderrp
	.long	0
L_blockSize100k$non_lazy_ptr:
	.indirect_symbol	_blockSize100k
	.long	0
L_exitValue$non_lazy_ptr:
	.indirect_symbol	_exitValue
	.long	0
L_forceOverwrite$non_lazy_ptr:
	.indirect_symbol	_forceOverwrite
	.long	0
L_inName$non_lazy_ptr:
	.indirect_symbol	_inName
	.long	0
L_noisy$non_lazy_ptr:
	.indirect_symbol	_noisy
	.long	0
L_outName$non_lazy_ptr:
	.indirect_symbol	_outName
	.long	0
L_outputHandleJustInCase$non_lazy_ptr:
	.indirect_symbol	_outputHandleJustInCase
	.long	0
L_progName$non_lazy_ptr:
	.indirect_symbol	_progName
	.long	0
L_smallMode$non_lazy_ptr:
	.indirect_symbol	_smallMode
	.long	0
L_verbosity$non_lazy_ptr:
	.indirect_symbol	_verbosity
	.long	0
L_workFactor$non_lazy_ptr:
	.indirect_symbol	_workFactor
	.long	0

.subsections_via_symbols
