.file	"int2bin.c"
	.text
	.p2align 4,,15
.globl decToBin_unroll
	.type	decToBin_unroll, @function
decToBin_unroll:
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%edi
	movl	$49, %edi
	movl	%edi, %edx
	pushl	%esi
	pushl	%ebx
	subl	$4, %esp
	movl	8(%ebp), %ebx
	movl	12(%ebp), %eax
	movl	%ebx, %esi
	notl	%esi
	shrl	$31, %esi
	movl	%esi, %ecx
	subb	%cl, %dl
	movl	%ebx, %esi
	movb	%dl, (%eax)
	testl	$1073741824, %ebx
	movl	%edi, %ecx
	sete	-13(%ebp)
	movl	%edi, %edx
	subb	-13(%ebp), %cl
	testl	$536870912, %ebx
	movb	%cl, 1(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$268435456, %ebx
	movb	%dl, 2(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testl	$134217728, %ebx
	movb	%cl, 3(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$67108864, %ebx
	movb	%dl, 4(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testl	$33554432, %ebx
	movb	%cl, 5(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$16777216, %ebx
	movb	%dl, 6(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testl	$8388608, %ebx
	movb	%cl, 7(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$4194304, %ebx
	movb	%dl, 8(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testl	$2097152, %ebx
	movb	%cl, 9(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$1048576, %ebx
	movb	%dl, 10(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testl	$524288, %ebx
	movb	%cl, 11(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$262144, %ebx
	movb	%dl, 12(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testl	$131072, %ebx
	movb	%cl, 13(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testl	$65536, %ebx
	movb	%dl, 14(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	andl	$-32768, %esi
	subb	-13(%ebp), %cl
	testw	%si, %si
	movb	%cl, 15(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$64, %bh
	movb	%dl, 16(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	$32, %bh
	movb	%cl, 17(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$16, %bh
	movb	%dl, 18(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	$8, %bh
	movb	%cl, 19(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$4, %bh
	movb	%dl, 20(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	$2, %bh
	movb	%cl, 21(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$1, %bh
	movb	%dl, 22(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	%bl, %bl
	movb	%cl, 23(%eax)
	movl	%edi, %ecx
	setns	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$64, %bl
	movb	%dl, 24(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	$32, %bl
	movb	%cl, 25(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$16, %bl
	movb	%dl, 26(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	$8, %bl
	movb	%cl, 27(%eax)
	movl	%edi, %ecx
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$4, %bl
	movb	%dl, 28(%eax)
	movl	%edi, %edx
	sete	-13(%ebp)
	subb	-13(%ebp), %cl
	testb	$2, %bl
	movb	%cl, 29(%eax)
	sete	-13(%ebp)
	subb	-13(%ebp), %dl
	testb	$1, %bl
	movl	%edi, %ebx
	sete	%cl
	movb	%dl, 30(%eax)
	movb	$0, 32(%eax)
	subb	%cl, %bl
	movb	%bl, 31(%eax)
	popl	%edx
	popl	%ebx
	popl	%esi
	popl	%edi
	popl	%ebp
	ret
	.size	decToBin_unroll, .-decToBin_unroll
	.section	.rodata
	.align 32
	.type	Asc4, @object
	.size	Asc4, 64
Asc4:
	.ascii	"0000"
	.ascii	"0001"
	.ascii	"0010"
	.ascii	"0011"
	.ascii	"0100"
	.ascii	"0101"
	.ascii	"0110"
	.ascii	"0111"
	.ascii	"1000"
	.ascii	"1001"
	.ascii	"1010"
	.ascii	"1011"
	.ascii	"1100"
	.ascii	"1101"
	.ascii	"1110"
	.ascii	"1111"
	.align 32
	.type	Asc8, @object
	.size	Asc8, 2048
Asc8:
	.ascii	"00000000"
	.ascii	"00000001"
	.ascii	"00000010"
	.ascii	"00000011"
	.ascii	"00000100"
	.ascii	"00000101"
	.ascii	"00000110"
	.ascii	"00000111"
	.ascii	"00001000"
	.ascii	"00001001"
	.ascii	"00001010"
	.ascii	"00001011"
	.ascii	"00001100"
	.ascii	"00001101"
	.ascii	"00001110"
	.ascii	"00001111"
	.ascii	"00010000"
	.ascii	"00010001"
	.ascii	"00010010"
	.ascii	"00010011"
	.ascii	"00010100"
	.ascii	"00010101"
	.ascii	"00010110"
	.ascii	"00010111"
	.ascii	"00011000"
	.ascii	"00011001"
	.ascii	"00011010"
	.ascii	"00011011"
	.ascii	"00011100"
	.ascii	"00011101"
	.ascii	"00011110"
	.ascii	"00011111"
	.ascii	"00100000"
	.ascii	"00100001"
	.ascii	"00100010"
	.ascii	"00100011"
	.ascii	"00100100"
	.ascii	"00100101"
	.ascii	"00100110"
	.ascii	"00100111"
	.ascii	"00101000"
	.ascii	"00101001"
	.ascii	"00101010"
	.ascii	"00101011"
	.ascii	"00101100"
	.ascii	"00101101"
	.ascii	"00101110"
	.ascii	"00101111"
	.ascii	"00110000"
	.ascii	"00110001"
	.ascii	"00110010"
	.ascii	"00110011"
	.ascii	"00110100"
	.ascii	"00110101"
	.ascii	"00110110"
	.ascii	"00110111"
	.ascii	"00111000"
	.ascii	"00111001"
	.ascii	"00111010"
	.ascii	"00111011"
	.ascii	"00111100"
	.ascii	"00111101"
	.ascii	"00111110"
	.ascii	"00111111"
	.ascii	"01000000"
	.ascii	"01000001"
	.ascii	"01000010"
	.ascii	"01000011"
	.ascii	"01000100"
	.ascii	"01000101"
	.ascii	"01000110"
	.ascii	"01000111"
	.ascii	"01001000"
	.ascii	"01001001"
	.ascii	"01001010"
	.ascii	"01001011"
	.ascii	"01001100"
	.ascii	"01001101"
	.ascii	"01001110"
	.ascii	"01001111"
	.ascii	"01010000"
	.ascii	"01010001"
	.ascii	"01010010"
	.ascii	"01010011"
	.ascii	"01010100"
	.ascii	"01010101"
	.ascii	"01010110"
	.ascii	"01010111"
	.ascii	"01011000"
	.ascii	"01011001"
	.ascii	"01011010"
	.ascii	"01011011"
	.ascii	"01011100"
	.ascii	"01011101"
	.ascii	"01011110"
	.ascii	"01011111"
	.ascii	"01100000"
	.ascii	"01100001"
	.ascii	"01100010"
	.ascii	"01100011"
	.ascii	"01100100"
	.ascii	"01100101"
	.ascii	"01100110"
	.ascii	"01100111"
	.ascii	"01101000"
	.ascii	"01101001"
	.ascii	"01101010"
	.ascii	"01101011"
	.ascii	"01101100"
	.ascii	"01101101"
	.ascii	"01101110"
	.ascii	"01101111"
	.ascii	"01110000"
	.ascii	"01110001"
	.ascii	"01110010"
	.ascii	"01110011"
	.ascii	"01110100"
	.ascii	"01110101"
	.ascii	"01110110"
	.ascii	"01110111"
	.ascii	"01111000"
	.ascii	"01111001"
	.ascii	"01111010"
	.ascii	"01111011"
	.ascii	"01111100"
	.ascii	"01111101"
	.ascii	"01111110"
	.ascii	"01111111"
	.ascii	"10000000"
	.ascii	"10000001"
	.ascii	"10000010"
	.ascii	"10000011"
	.ascii	"10000100"
	.ascii	"10000101"
	.ascii	"10000110"
	.ascii	"10000111"
	.ascii	"10001000"
	.ascii	"10001001"
	.ascii	"10001010"
	.ascii	"10001011"
	.ascii	"10001100"
	.ascii	"10001101"
	.ascii	"10001110"
	.ascii	"10001111"
	.ascii	"10010000"
	.ascii	"10010001"
	.ascii	"10010010"
	.ascii	"10010011"
	.ascii	"10010100"
	.ascii	"10010101"
	.ascii	"10010110"
	.ascii	"10010111"
	.ascii	"10011000"
	.ascii	"10011001"
	.ascii	"10011010"
	.ascii	"10011011"
	.ascii	"10011100"
	.ascii	"10011101"
	.ascii	"10011110"
	.ascii	"10011111"
	.ascii	"10100000"
	.ascii	"10100001"
	.ascii	"10100010"
	.ascii	"10100011"
	.ascii	"10100100"
	.ascii	"10100101"
	.ascii	"10100110"
	.ascii	"10100111"
	.ascii	"10101000"
	.ascii	"10101001"
	.ascii	"10101010"
	.ascii	"10101011"
	.ascii	"10101100"
	.ascii	"10101101"
	.ascii	"10101110"
	.ascii	"10101111"
	.ascii	"10110000"
	.ascii	"10110001"
	.ascii	"10110010"
	.ascii	"10110011"
	.ascii	"10110100"
	.ascii	"10110101"
	.ascii	"10110110"
	.ascii	"10110111"
	.ascii	"10111000"
	.ascii	"10111001"
	.ascii	"10111010"
	.ascii	"10111011"
	.ascii	"10111100"
	.ascii	"10111101"
	.ascii	"10111110"
	.ascii	"10111111"
	.ascii	"11000000"
	.ascii	"11000001"
	.ascii	"11000010"
	.ascii	"11000011"
	.ascii	"11000100"
	.ascii	"11000101"
	.ascii	"11000110"
	.ascii	"11000111"
	.ascii	"11001000"
	.ascii	"11001001"
	.ascii	"11001010"
	.ascii	"11001011"
	.ascii	"11001100"
	.ascii	"11001101"
	.ascii	"11001110"
	.ascii	"11001111"
	.ascii	"11010000"
	.ascii	"11010001"
	.ascii	"11010010"
	.ascii	"11010011"
	.ascii	"11010100"
	.ascii	"11010101"
	.ascii	"11010110"
	.ascii	"11010111"
	.ascii	"11011000"
	.ascii	"11011001"
	.ascii	"11011010"
	.ascii	"11011011"
	.ascii	"11011100"
	.ascii	"11011101"
	.ascii	"11011110"
	.ascii	"11011111"
	.ascii	"11100000"
	.ascii	"11100001"
	.ascii	"11100010"
	.ascii	"11100011"
	.ascii	"11100100"
	.ascii	"11100101"
	.ascii	"11100110"
	.ascii	"11100111"
	.ascii	"11101000"
	.ascii	"11101001"
	.ascii	"11101010"
	.ascii	"11101011"
	.ascii	"11101100"
	.ascii	"11101101"
	.ascii	"11101110"
	.ascii	"11101111"
	.ascii	"11110000"
	.ascii	"11110001"
	.ascii	"11110010"
	.ascii	"11110011"
	.ascii	"11110100"
	.ascii	"11110101"
	.ascii	"11110110"
	.ascii	"11110111"
	.ascii	"11111000"
	.ascii	"11111001"
	.ascii	"11111010"
	.ascii	"11111011"
	.ascii	"11111100"
	.ascii	"11111101"
	.ascii	"11111110"
	.ascii	"11111111"
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC17:
	.string	"%u iterations:\n"
.LC18:
	.string	"decToBin"
.LC20:
	.string	" %.3f secs\n"
.LC21:
	.string	"int2bin tiny"
.LC22:
	.string	"int2bin"
.LC23:
	.string	"int2bin_unroll"
.LC24:
	.string	"int2bin32"
.LC25:
	.string	"int2bin32_unroll"
.LC26:
	.string	"int2bin32_unroll_order"
.LC27:
	.string	"decToBin_unroll"
	.section	.rodata.cst4,"aM",@progbits,4
	.align 4
.LC19:
	.long	1232348160
	.text
	.p2align 4,,15
.globl main
	.type	main, @function
main:
	pushl	%ebp
	movl	$20000000, %ecx
	movl	%esp, %ebp
	pushl	%edi
	movl	$decToBin, %edi
	pushl	%esi
	leal	-72(%ebp), %esi
	pushl	%ebx
	subl	$556, %esp
	movl	$20000000, %ebx
	andl	$-16, %esp
	movl	%ecx, 4(%esp)
	movl	$.LC17, (%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC18, (%esp)
	call	test
	xorl	%edx, %edx
	movl	%edx, 4(%esp)
	leal	-88(%ebp), %edx
	movl	%edx, (%esp)
	call	gettimeofday
	.p2align 4,,15
.L117:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L117
	xorl	%ecx, %ecx
	leal	-80(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-168(%ebp), %esi
	call	gettimeofday
	movl	-88(%ebp), %edi
	movl	-80(%ebp), %ebx
	movl	-84(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-76(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$int2bin_tiny, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC21, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-152(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L122:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L122
	xorl	%ecx, %ecx
	leal	-160(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-232(%ebp), %esi
	call	gettimeofday
	movl	-168(%ebp), %edi
	movl	-160(%ebp), %ebx
	movl	-164(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-156(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$int2bin, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC22, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-216(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L127:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L127
	xorl	%ecx, %ecx
	leal	-224(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-296(%ebp), %esi
	call	gettimeofday
	movl	-232(%ebp), %edi
	movl	-224(%ebp), %ebx
	movl	-228(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-220(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$int2bin_unroll, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC23, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-280(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L132:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L132
	xorl	%ecx, %ecx
	leal	-288(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-360(%ebp), %esi
	call	gettimeofday
	movl	-296(%ebp), %edi
	movl	-288(%ebp), %ebx
	movl	-292(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-284(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$int2bin32, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC24, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-344(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L137:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L137
	xorl	%ecx, %ecx
	leal	-352(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-424(%ebp), %esi
	call	gettimeofday
	movl	-360(%ebp), %edi
	movl	-352(%ebp), %ebx
	movl	-356(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-348(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$int2bin32_unroll, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC25, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-408(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L142:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L142
	xorl	%ecx, %ecx
	leal	-416(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-488(%ebp), %esi
	call	gettimeofday
	movl	-424(%ebp), %edi
	movl	-416(%ebp), %ebx
	movl	-420(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-412(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$int2bin32_unroll_order, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC26, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-472(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L147:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L147
	xorl	%ecx, %ecx
	leal	-480(%ebp), %esi
	movl	%ecx, 4(%esp)
	movl	%esi, (%esp)
	leal	-552(%ebp), %esi
	call	gettimeofday
	movl	-488(%ebp), %edi
	movl	-480(%ebp), %ebx
	movl	-484(%ebp), %edx
	imull	$1000000, %edi, %edi
	movl	-476(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%edx, %edi
	addl	%eax, %ebx
	pushl	%edi
	movl	$decToBin_unroll, %edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	movl	$20000000, %ebx
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	movl	%edi, 4(%esp)
	movl	$.LC27, (%esp)
	call	test
	movl	%esi, (%esp)
	xorl	%ecx, %ecx
	leal	-536(%ebp), %esi
	movl	%ecx, 4(%esp)
	call	gettimeofday
.L152:
	movl	%ebx, (%esp)
	movl	$36, %edx
	decl	%ebx
	movl	%edx, 8(%esp)
	movl	%esi, 4(%esp)
	call	*%edi
	cmpl	$-1, %ebx
	jne	.L152
	leal	-544(%ebp), %ecx
	xorl	%edx, %edx
	movl	%edx, 4(%esp)
	movl	%ecx, (%esp)
	call	gettimeofday
	movl	-552(%ebp), %edi
	movl	-544(%ebp), %ebx
	movl	-548(%ebp), %esi
	imull	$1000000, %edi, %edi
	movl	-540(%ebp), %eax
	imull	$1000000, %ebx, %ebx
	addl	%esi, %edi
	addl	%eax, %ebx
	pushl	%edi
	fildl	(%esp)
	movl	%ebx, (%esp)
	fildl	(%esp)
	fxch	%st(1)
	addl	$4, %esp
	movl	$.LC20, (%esp)
	fstl	-104(%ebp)
	fxch	%st(1)
	fstl	-96(%ebp)
	fsubp	%st, %st(1)
	fdivs	.LC19
	fstpl	4(%esp)
	call	printf
	leal	-12(%ebp), %esp
	xorl	%eax, %eax
	popl	%ebx
	popl	%esi
	popl	%edi
	popl	%ebp
	ret
	.size	main, .-main
	.p2align 4,,15
.globl decToBin
	.type	decToBin, @function
decToBin:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %ecx
	pushl	%esi
	movl	12(%ebp), %esi
	pushl	%ebx
	xorl	%ebx, %ebx
	.p2align 4,,15
.L262:
	movl	%ecx, %edx
	movb	$49, %al
	notl	%edx
	shrl	$31, %edx
	addl	%ecx, %ecx
	subb	%dl, %al
	movb	%al, (%ebx,%esi)
	incl	%ebx
	cmpl	$31, %ebx
	jbe	.L262
	movb	$0, 32(%esi)
	movl	%esi, %eax
	popl	%ebx
	popl	%esi
	popl	%ebp
	ret
	.size	decToBin, .-decToBin
	.p2align 4,,15
.globl int2bin_tiny
	.type	int2bin_tiny, @function
int2bin_tiny:
	pushl	%ebp
	movl	%esp, %ebp
	movl	12(%ebp), %edx
	pushl	%ebx
	movl	8(%ebp), %ecx
	movl	$32, %ebx
	addl	$32, %edx
	movb	$0, (%edx)
	decl	%edx
	.p2align 4,,15
.L266:
	movb	%cl, %al
	andb	$1, %al
	shrl	%ecx
	addb	$48, %al
	movb	%al, (%edx)
	decl	%edx
	decl	%ebx
	jne	.L266
	popl	%ebx
	leal	1(%edx), %eax
	popl	%ebp
	ret
	.size	int2bin_tiny, .-int2bin_tiny
	.p2align 4,,15
.globl int2bin
	.type	int2bin, @function
int2bin:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %ecx
	pushl	%esi
	movl	12(%ebp), %esi
	pushl	%ebx
	movl	$8, %ebx
	leal	28(%esi), %edx
	.p2align 4,,15
.L271:
	movl	%ecx, %eax
	andl	$15, %eax
	shrl	$4, %ecx
	movl	Asc4(,%eax,4), %eax
	movl	%eax, (%edx)
	subl	$4, %edx
	decl	%ebx
	jne	.L271
	movb	$0, 32(%esi)
	movl	%esi, %eax
	popl	%ebx
	popl	%esi
	popl	%ebp
	ret
	.size	int2bin, .-int2bin
	.p2align 4,,15
.globl int2bin_unroll
	.type	int2bin_unroll, @function
int2bin_unroll:
	pushl	%ebp
	movl	%esp, %ebp
	movl	8(%ebp), %ecx
	pushl	%ebx
	movl	12(%ebp), %eax
	movl	$Asc4, %ebx
	movl	%ecx, %edx
	andl	$15, %edx
	movl	(%ebx,%edx,4), %edx
	movl	%edx, 28(%eax)
	movl	%ecx, %edx
	shrl	$4, %edx
	andl	$15, %edx
	movl	(%ebx,%edx,4), %edx
	movl	%edx, 24(%eax)
	movl	%ecx, %edx
	shrl	$8, %edx
	andl	$15, %edx
	movl	(%ebx,%edx,4), %edx
	movl	%edx, 20(%eax)
	movl	%ecx, %edx
	shrl	$12, %edx
	andl	$15, %edx
	movl	(%ebx,%edx,4), %edx
	movl	%edx, 16(%eax)
	movl	%ecx, %edx
	shrl	$16, %edx
	andl	$15, %edx
	movl	(%ebx,%edx,4), %edx
	movl	%edx, 12(%eax)
	movl	%ecx, %edx
	shrl	$20, %edx
	andl	$15, %edx
	shrl	$24, %ecx
	movl	(%ebx,%edx,4), %edx
	movl	%edx, 8(%eax)
	movl	%ecx, %edx
	andl	$15, %edx
	movl	(%ebx,%edx,4), %edx
	shrl	$4, %ecx
	movl	%edx, 4(%eax)
	movl	(%ebx,%ecx,4), %edx
	movb	$0, 32(%eax)
	movl	%edx, (%eax)
	popl	%ebx
	popl	%ebp
	ret
	.size	int2bin_unroll, .-int2bin_unroll
	.p2align 4,,15
.globl int2bin32
	.type	int2bin32, @function
int2bin32:
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%edi
	movl	12(%ebp), %edi
	pushl	%esi
	movl	$4, %esi
	leal	24(%edi), %ecx
	pushl	%ebx
	movl	8(%ebp), %ebx
	.p2align 4,,15
.L277:
	movzbl	%bl,%eax
	movl	Asc8(,%eax,8), %edx
	shrl	$8, %ebx
	movl	%edx, (%ecx)
	movl	Asc8+4(,%eax,8), %edx
	movl	%edx, 4(%ecx)
	subl	$8, %ecx
	decl	%esi
	jne	.L277
	movb	$0, 32(%edi)
	movl	%edi, %eax
	popl	%ebx
	popl	%esi
	popl	%edi
	popl	%ebp
	ret
	.size	int2bin32, .-int2bin32
	.p2align 4,,15
.globl int2bin32_unroll
	.type	int2bin32_unroll, @function
int2bin32_unroll:
	pushl	%ebp
	movl	$Asc8, %ecx
	movl	%esp, %ebp
	subl	$8, %esp
	movl	12(%ebp), %eax
	movl	%ebx, (%esp)
	movl	8(%ebp), %ebx
	movl	%esi, 4(%esp)
	movb	$0, 32(%eax)
	movzbl	%bl, %esi
	movl	(%ecx,%esi,8), %edx
	movl	%edx, 24(%eax)
	movl	4(%ecx,%esi,8), %edx
	movzbl	%bh, %esi
	shrl	$16, %ebx
	movl	%edx, 28(%eax)
	movl	(%ecx,%esi,8), %edx
	movl	%edx, 16(%eax)
	movl	4(%ecx,%esi,8), %edx
	movzbl	%bl, %esi
	shrl	$8, %ebx
	movl	%edx, 20(%eax)
	movl	(%ecx,%esi,8), %edx
	movl	%edx, 8(%eax)
	movl	4(%ecx,%esi,8), %edx
	movl	%edx, 12(%eax)
	movl	(%ecx,%ebx,8), %esi
	movl	%esi, (%eax)
	movl	4(%ecx,%ebx,8), %esi
	movl	%esi, 4(%eax)
	movl	(%esp), %ebx
	movl	4(%esp), %esi
	movl	%ebp, %esp
	popl	%ebp
	ret
	.size	int2bin32_unroll, .-int2bin32_unroll
	.p2align 4,,15
.globl int2bin32_unroll_order
	.type	int2bin32_unroll_order, @function
int2bin32_unroll_order:
	pushl	%ebp
	movl	$Asc8, %ecx
	movl	%esp, %ebp
	subl	$8, %esp
	movl	12(%ebp), %eax
	movl	%ebx, (%esp)
	movl	8(%ebp), %ebx
	movl	%esi, 4(%esp)
	movl	%ebx, %esi
	shrl	$24, %esi
	movl	(%ecx,%esi,8), %edx
	movl	%edx, (%eax)
	movl	4(%ecx,%esi,8), %edx
	movzbl	%bh, %esi
	movl	%edx, 4(%eax)
	movl	(%ecx,%esi,8), %edx
	movl	%edx, 16(%eax)
	movl	4(%ecx,%esi,8), %edx
	movzbl	%bl, %esi
	shrl	$16, %ebx
	movzbl	%bl, %ebx
	movl	%edx, 20(%eax)
	movl	(%ecx,%esi,8), %edx
	movl	%edx, 24(%eax)
	movl	4(%ecx,%esi,8), %edx
	movl	%edx, 28(%eax)
	movl	(%ecx,%ebx,8), %esi
	movl	%esi, 8(%eax)
	movl	4(%ecx,%ebx,8), %esi
	movb	$0, 32(%eax)
	movl	%esi, 12(%eax)
	movl	(%esp), %ebx
	movl	4(%esp), %esi
	movl	%ebp, %esp
	popl	%ebp
	ret
	.size	int2bin32_unroll_order, .-int2bin32_unroll_order
	.section	.rodata.str1.32,"aMS",@progbits,1
	.align 32
.LC1:
	.string	"00000000000000000000000000000000"
	.section	.rodata.str1.1
.LC0:
	.string	"%30s "
	.section	.rodata.str1.32
	.align 32
.LC5:
	.string	"00000000000000000000000000000001"
	.align 32
.LC7:
	.string	"00000000000000000000000000000011"
	.align 32
.LC9:
	.string	"00000000000000000000000000010000"
	.align 32
.LC11:
	.string	"00000000000000010000000000000000"
	.align 32
.LC13:
	.string	"10000000000000000000000000000000"
	.align 32
.LC15:
	.string	"11111111111111111111111111111111"
	.align 32
.LC16:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"11111111111111111111111111111111\") && __built"
	.ascii	"in_constant_p (f(0xFFFFFFFF, buf, sizeof buf)) && (__s1_len "
	.ascii	"= strlen (\"11111111111111111111111111111111\"), __s2_len = "
	.ascii	"strlen (f(0xFFFFFFFF, buf, sizeof buf)), (!((size_t)(const v"
	.ascii	"oid *)((\"11111111111111111111111111111111\") + 1) - (size_t"
	.ascii	")(const void *)(\"11111111111111111111111111111111\") == 1) "
	.ascii	"|| __s1_len >= 4) && (!((size_t)(const void *)((f(0xFFFFFFFF"
	.ascii	", buf, sizeof buf)) + 1) - (size_t)(const void *)(f(0xFFFFFF"
	.ascii	"FF, buf, sizeof buf)) == 1) || __s2_len >= 4)) ? __builtin_s"
	.ascii	"trcmp (\"11111111111111111111111111111111\", f(0xFFFFFFFF, b"
	.ascii	"uf, sizeof buf)) : (__builtin_constant_p (\"1111111111111111"
	.ascii	"1111111111111111\") && ((size_t)(const void *)((\"1111111111"
	.ascii	"1111111111111111111111\") + 1) - (size_t)(const void *)(\"11"
	.ascii	"111111111111111111111111111111\") == 1) && (__s1_len = strle"
	.ascii	"n (\"11111111111111111111111111111111\"), __s1_len < 4) ? (_"
	.ascii	"_builtin_constant_p (f(0xFFFFFFFF, buf, sizeof buf)) && ((si"
	.ascii	"ze_t)(const void *)((f(0xFFFFFFFF, buf, sizeof buf)) + 1) - "
	.ascii	"(size_t)(const void *)(f(0xFFFFFFFF, buf, sizeof buf)) == 1)"
	.ascii	" ? __builtin_strcmp (\"11111111111111111111111111111111\", f"
	.ascii	"(0xFFFFFFFF, buf, sizeof buf)) : (__extension__ ({ __const u"
	.ascii	"nsigned char *__s2 = (__const unsigned char *) (__const char"
	.ascii	" *) (f(0xFFFFFFFF, buf, sizeof buf)); register int __result "
	.ascii	"= (((__const unsigned char *) (__const char *) (\"1111111111"
	.ascii	"1111111111111111111111\"))[0] - __s2[0]); if (__s1_len > 0 &"
	.ascii	"& __result == 0) { __result = (((__const unsigned char *) (_"
	.ascii	"_const char *) (\"11111111111111111111111111111111\"))[1] - "
	.ascii	"__s2[1]); if (__s1_len > 1 && __result == 0) { __result = (("
	.ascii	"(__const unsigned char *) (__const char *) (\"11111111111111"
	.ascii	"111111111111111111\"))[2] - __s2[2]); if (__s1_len > 2 && __"
	.ascii	"result == 0) __result = (((__const unsigned char *) (__const"
	.ascii	" char *) (\"11111111111111111111111111111111\"))[3] - __s2[3"
	.ascii	"]); } } __result; }))) : (__builtin_constant_p (f(0xFFFFFFFF"
	.ascii	", buf, sizeof buf)) && ((size_t)(const void *)(("
	.ascii	"f(0xFFFFFFFF, buf, sizeof buf)) + 1) - (size_t)(const void *"
	.ascii	")(f(0xFFFFFFFF, buf, sizeof buf)) == 1) && (__s2_len = strle"
	.ascii	"n (f(0xFFFFFFFF, buf, sizeof buf)), __s2_len < 4) ? (__built"
	.ascii	"in_constant_p (\"11111111111111111111111111111111\") && ((si"
	.ascii	"ze_t)(const void *)((\"11111111111111111111111111111111\") +"
	.ascii	" 1) - (size_t)(const void *)(\"11111111111111111111111111111"
	.ascii	"111\") == 1) ? __builtin_strcmp (\"1111111111111111111111111"
	.ascii	"1111111\", f(0xFFFFFFFF, buf, sizeof buf)) : (__extension__ "
	.ascii	"({ __const unsigned char *__s1 = (__const unsigned char *) ("
	.ascii	"__const char *) (\"11111111111111111111111111111111\"); regi"
	.ascii	"ster int __result = __s1[0] - ((__const unsigned char *) (__"
	.ascii	"const char *) (f(0xFFFFFFFF, buf, sizeof buf)))[0]; if (__s2"
	.ascii	"_len > 0 && __result == 0) { __result = (__s1[1] - ((__const"
	.ascii	" unsigned char *) (__const char *) (f(0xFFFFFFFF, buf, sizeo"
	.ascii	"f buf)))[1]); if (__s2_len > 1 && __result == 0) { __result "
	.ascii	"= (__s1[2] - ((__const unsigned char *) (__const char *) (f("
	.ascii	"0xFFFFFFFF, buf, sizeof buf)))[2]"
	.string	"); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(0xFFFFFFFF, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"11111111111111111111111111111111\", f(0xFFFFFFFF, buf, sizeof buf))))); })"
	.section	.rodata.str1.1
.LC2:
	.string	"test"
.LC3:
	.string	"int2bin.c"
	.section	.rodata.str1.32
	.align 32
.LC14:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"10000000000000000000000000000000\") && __built"
	.ascii	"in_constant_p (f(0x80000000, buf, sizeof buf)) && (__s1_len "
	.ascii	"= strlen (\"10000000000000000000000000000000\"), __s2_len = "
	.ascii	"strlen (f(0x80000000, buf, sizeof buf)), (!((size_t)(const v"
	.ascii	"oid *)((\"10000000000000000000000000000000\") + 1) - (size_t"
	.ascii	")(const void *)(\"10000000000000000000000000000000\") == 1) "
	.ascii	"|| __s1_len >= 4) && (!((size_t)(const void *)((f(0x80000000"
	.ascii	", buf, sizeof buf)) + 1) - (size_t)(const void *)(f(0x800000"
	.ascii	"00, buf, sizeof buf)) == 1) || __s2_len >= 4)) ? __builtin_s"
	.ascii	"trcmp (\"10000000000000000000000000000000\", f(0x80000000, b"
	.ascii	"uf, sizeof buf)) : (__builtin_constant_p (\"1000000000000000"
	.ascii	"0000000000000000\") && ((size_t)(const void *)((\"1000000000"
	.ascii	"0000000000000000000000\") + 1) - (size_t)(const void *)(\"10"
	.ascii	"000000000000000000000000000000\") == 1) && (__s1_len = strle"
	.ascii	"n (\"10000000000000000000000000000000\"), __s1_len < 4) ? (_"
	.ascii	"_builtin_constant_p (f(0x80000000, buf, sizeof buf)) && ((si"
	.ascii	"ze_t)(const void *)((f(0x80000000, buf, sizeof buf)) + 1) - "
	.ascii	"(size_t)(const void *)(f(0x80000000, buf, sizeof buf)) == 1)"
	.ascii	" ? __builtin_strcmp (\"10000000000000000000000000000000\", f"
	.ascii	"(0x80000000, buf, sizeof buf)) : (__extension__ ({ __const u"
	.ascii	"nsigned char *__s2 = (__const unsigned char *) (__const char"
	.ascii	" *) (f(0x80000000, buf, sizeof buf)); register int __result "
	.ascii	"= (((__const unsigned char *) (__const char *) (\"1000000000"
	.ascii	"0000000000000000000000\"))[0] - __s2[0]); if (__s1_len > 0 &"
	.ascii	"& __result == 0) { __result = (((__const unsigned char *) (_"
	.ascii	"_const char *) (\"10000000000000000000000000000000\"))[1] - "
	.ascii	"__s2[1]); if (__s1_len > 1 && __result == 0) { __result = (("
	.ascii	"(__const unsigned char *) (__const char *) (\"10000000000000"
	.ascii	"000000000000000000\"))[2] - __s2[2]); if (__s1_len > 2 && __"
	.ascii	"result == 0) __result = (((__const unsigned char *) (__const"
	.ascii	" char *) (\"10000000000000000000000000000000\"))[3] - __s2[3"
	.ascii	"]); } } __result; }))) : (__builtin_constant_p (f(0x80000000"
	.ascii	", buf, sizeof buf)) && ((size_t)(const void *)(("
	.ascii	"f(0x80000000, buf, sizeof buf)) + 1) - (size_t)(const void *"
	.ascii	")(f(0x80000000, buf, sizeof buf)) == 1) && (__s2_len = strle"
	.ascii	"n (f(0x80000000, buf, sizeof buf)), __s2_len < 4) ? (__built"
	.ascii	"in_constant_p (\"10000000000000000000000000000000\") && ((si"
	.ascii	"ze_t)(const void *)((\"10000000000000000000000000000000\") +"
	.ascii	" 1) - (size_t)(const void *)(\"10000000000000000000000000000"
	.ascii	"000\") == 1) ? __builtin_strcmp (\"1000000000000000000000000"
	.ascii	"0000000\", f(0x80000000, buf, sizeof buf)) : (__extension__ "
	.ascii	"({ __const unsigned char *__s1 = (__const unsigned char *) ("
	.ascii	"__const char *) (\"10000000000000000000000000000000\"); regi"
	.ascii	"ster int __result = __s1[0] - ((__const unsigned char *) (__"
	.ascii	"const char *) (f(0x80000000, buf, sizeof buf)))[0]; if (__s2"
	.ascii	"_len > 0 && __result == 0) { __result = (__s1[1] - ((__const"
	.ascii	" unsigned char *) (__const char *) (f(0x80000000, buf, sizeo"
	.ascii	"f buf)))[1]); if (__s2_len > 1 && __result == 0) { __result "
	.ascii	"= (__s1[2] - ((__const unsigned char *) (__const char *) (f("
	.ascii	"0x80000000, buf, sizeof buf)))[2]"
	.string	"); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(0x80000000, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"10000000000000000000000000000000\", f(0x80000000, buf, sizeof buf))))); })"
	.align 32
.LC12:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"00000000000000010000000000000000\") && __built"
	.ascii	"in_constant_p (f(1 << 16, buf, sizeof buf)) && (__s1_len = s"
	.ascii	"trlen (\"00000000000000010000000000000000\"), __s2_len = str"
	.ascii	"len (f(1 << 16, buf, sizeof buf)), (!((size_t)(const void *)"
	.ascii	"((\"00000000000000010000000000000000\") + 1) - (size_t)(cons"
	.ascii	"t void *)(\"00000000000000010000000000000000\") == 1) || __s"
	.ascii	"1_len >= 4) && (!((size_t)(const void *)((f(1 << 16, buf, si"
	.ascii	"zeof buf)) + 1) - (size_t)(const void *)(f(1 << 16, buf, siz"
	.ascii	"eof buf)) == 1) || __s2_len >= 4)) ? __builtin_strcmp (\"000"
	.ascii	"00000000000010000000000000000\", f(1 << 16, buf, sizeof buf)"
	.ascii	") : (__builtin_constant_p (\"0000000000000001000000000000000"
	.ascii	"0\") && ((size_t)(const void *)((\"0000000000000001000000000"
	.ascii	"0000000\") + 1) - (size_t)(const void *)(\"00000000000000010"
	.ascii	"000000000000000\") == 1) && (__s1_len = strlen (\"0000000000"
	.ascii	"0000010000000000000000\"), __s1_len < 4) ? (__builtin_consta"
	.ascii	"nt_p (f(1 << 16, buf, sizeof buf)) && ((size_t)(const void *"
	.ascii	")((f(1 << 16, buf, sizeof buf)) + 1) - (size_t)(const void *"
	.ascii	")(f(1 << 16, buf, sizeof buf)) == 1) ? __builtin_strcmp (\"0"
	.ascii	"0000000000000010000000000000000\", f(1 << 16, buf, sizeof bu"
	.ascii	"f)) : (__extension__ ({ __const unsigned char *__s2 = (__con"
	.ascii	"st unsigned char *) (__const char *) (f(1 << 16, buf, sizeof"
	.ascii	" buf)); register int __result = (((__const unsigned char *) "
	.ascii	"(__const char *) (\"00000000000000010000000000000000\"))[0] "
	.ascii	"- __s2[0]); if (__s1_len > 0 && __result == 0) { __result = "
	.ascii	"(((__const unsigned char *) (__const char *) (\"000000000000"
	.ascii	"00010000000000000000\"))[1] - __s2[1]); if (__s1_len > 1 && "
	.ascii	"__result == 0) { __result = (((__const unsigned char *) (__c"
	.ascii	"onst char *) (\"00000000000000010000000000000000\"))[2] - __"
	.ascii	"s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__c"
	.ascii	"onst unsigned char *) (__const char *) (\"000000000000000100"
	.ascii	"00000000000000\"))[3] - __s2[3]); } } __result; }))) : (__bu"
	.ascii	"iltin_constant_p (f(1 << 16, buf, sizeof buf)) && ((size_t)("
	.ascii	"const void *)((f(1 << 16, buf, sizeof buf)) + 1)"
	.ascii	" - (size_t)(const void *)(f(1 << 16, buf, sizeof buf)) == 1)"
	.ascii	" && (__s2_len = strlen (f(1 << 16, buf, sizeof buf)), __s2_l"
	.ascii	"en < 4) ? (__builtin_constant_p (\"0000000000000001000000000"
	.ascii	"0000000\") && ((size_t)(const void *)((\"0000000000000001000"
	.ascii	"0000000000000\") + 1) - (size_t)(const void *)(\"00000000000"
	.ascii	"000010000000000000000\") == 1) ? __builtin_strcmp (\"0000000"
	.ascii	"0000000010000000000000000\", f(1 << 16, buf, sizeof buf)) : "
	.ascii	"(__extension__ ({ __const unsigned char *__s1 = (__const uns"
	.ascii	"igned char *) (__const char *) (\"00000000000000010000000000"
	.ascii	"000000\"); register int __result = __s1[0] - ((__const unsig"
	.ascii	"ned char *) (__const char *) (f(1 << 16, buf, sizeof buf)))["
	.ascii	"0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1]"
	.ascii	" - ((__const unsigned char *) (__const char *) (f(1 << 16, b"
	.ascii	"uf, sizeof buf)))[1]); if (__s2_len > 1 && __result == 0) { "
	.ascii	"__result = (__s1[2] - ((__const unsigned char *) (__const ch"
	.ascii	"ar *) (f(1 << 16, buf, sizeof buf"
	.string	")))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(1 << 16, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"00000000000000010000000000000000\", f(1 << 16, buf, sizeof buf))))); })"
	.align 32
.LC10:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"00000000000000000000000000010000\") && __built"
	.ascii	"in_constant_p (f(1 << 4, buf, sizeof buf)) && (__s1_len = st"
	.ascii	"rlen (\"00000000000000000000000000010000\"), __s2_len = strl"
	.ascii	"en (f(1 << 4, buf, sizeof buf)), (!((size_t)(const void *)(("
	.ascii	"\"00000000000000000000000000010000\") + 1) - (size_t)(const "
	.ascii	"void *)(\"00000000000000000000000000010000\") == 1) || __s1_"
	.ascii	"len >= 4) && (!((size_t)(const void *)((f(1 << 4, buf, sizeo"
	.ascii	"f buf)) + 1) - (size_t)(const void *)(f(1 << 4, buf, sizeof "
	.ascii	"buf)) == 1) || __s2_len >= 4)) ? __builtin_strcmp (\"0000000"
	.ascii	"0000000000000000000010000\", f(1 << 4, buf, sizeof buf)) : ("
	.ascii	"__builtin_constant_p (\"00000000000000000000000000010000\") "
	.ascii	"&& ((size_t)(const void *)((\"000000000000000000000000000100"
	.ascii	"00\") + 1) - (size_t)(const void *)(\"0000000000000000000000"
	.ascii	"0000010000\") == 1) && (__s1_len = strlen (\"000000000000000"
	.ascii	"00000000000010000\"), __s1_len < 4) ? (__builtin_constant_p "
	.ascii	"(f(1 << 4, buf, sizeof buf)) && ((size_t)(const void *)((f(1"
	.ascii	" << 4, buf, sizeof buf)) + 1) - (size_t)(const void *)(f(1 <"
	.ascii	"< 4, buf, sizeof buf)) == 1) ? __builtin_strcmp (\"000000000"
	.ascii	"00000000000000000010000\", f(1 << 4, buf, sizeof buf)) : (__"
	.ascii	"extension__ ({ __const unsigned char *__s2 = (__const unsign"
	.ascii	"ed char *) (__const char *) (f(1 << 4, buf, sizeof buf)); re"
	.ascii	"gister int __result = (((__const unsigned char *) (__const c"
	.ascii	"har *) (\"00000000000000000000000000010000\"))[0] - __s2[0])"
	.ascii	"; if (__s1_len > 0 && __result == 0) { __result = (((__const"
	.ascii	" unsigned char *) (__const char *) (\"0000000000000000000000"
	.ascii	"0000010000\"))[1] - __s2[1]); if (__s1_len > 1 && __result ="
	.ascii	"= 0) { __result = (((__const unsigned char *) (__const char "
	.ascii	"*) (\"00000000000000000000000000010000\"))[2] - __s2[2]); if"
	.ascii	" (__s1_len > 2 && __result == 0) __result = (((__const unsig"
	.ascii	"ned char *) (__const char *) (\"0000000000000000000000000001"
	.ascii	"0000\"))[3] - __s2[3]); } } __result; }))) : (__builtin_cons"
	.ascii	"tant_p (f(1 << 4, buf, sizeof buf)) && ((size_t)(const void "
	.ascii	"*)((f(1 << 4, buf, sizeof buf)) + 1) - (size_t)("
	.ascii	"const void *)(f(1 << 4, buf, sizeof buf)) == 1) && (__s2_len"
	.ascii	" = strlen (f(1 << 4, buf, sizeof buf)), __s2_len < 4) ? (__b"
	.ascii	"uiltin_constant_p (\"00000000000000000000000000010000\") && "
	.ascii	"((size_t)(const void *)((\"00000000000000000000000000010000\""
	.ascii	") + 1) - (size_t)(const void *)(\"00000000000000000000000000"
	.ascii	"010000\") == 1) ? __builtin_strcmp (\"0000000000000000000000"
	.ascii	"0000010000\", f(1 << 4, buf, sizeof buf)) : (__extension__ ("
	.ascii	"{ __const unsigned char *__s1 = (__const unsigned char *) (_"
	.ascii	"_const char *) (\"00000000000000000000000000010000\"); regis"
	.ascii	"ter int __result = __s1[0] - ((__const unsigned char *) (__c"
	.ascii	"onst char *) (f(1 << 4, buf, sizeof buf)))[0]; if (__s2_len "
	.ascii	"> 0 && __result == 0) { __result = (__s1[1] - ((__const unsi"
	.ascii	"gned char *) (__const char *) (f(1 << 4, buf, sizeof buf)))["
	.ascii	"1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2"
	.ascii	"] - ((__const unsigned char *) (__const char *) (f(1 << 4, b"
	.ascii	"uf, sizeof b"
	.string	"uf)))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(1 << 4, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"00000000000000000000000000010000\", f(1 << 4, buf, sizeof buf))))); })"
	.align 32
.LC8:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"00000000000000000000000000000011\") && __built"
	.ascii	"in_constant_p (f(0x3, buf, sizeof buf)) && (__s1_len = strle"
	.ascii	"n (\"00000000000000000000000000000011\"), __s2_len = strlen "
	.ascii	"(f(0x3, buf, sizeof buf)), (!((size_t)(const void *)((\"0000"
	.ascii	"0000000000000000000000000011\") + 1) - (size_t)(const void *"
	.ascii	")(\"00000000000000000000000000000011\") == 1) || __s1_len >="
	.ascii	" 4) && (!((size_t)(const void *)((f(0x3, buf, sizeof buf)) +"
	.ascii	" 1) - (size_t)(const void *)(f(0x3, buf, sizeof buf)) == 1) "
	.ascii	"|| __s2_len >= 4)) ? __builtin_strcmp (\"0000000000000000000"
	.ascii	"0000000000011\", f(0x3, buf, sizeof buf)) : (__builtin_const"
	.ascii	"ant_p (\"00000000000000000000000000000011\") && ((size_t)(co"
	.ascii	"nst void *)((\"00000000000000000000000000000011\") + 1) - (s"
	.ascii	"ize_t)(const void *)(\"00000000000000000000000000000011\") ="
	.ascii	"= 1) && (__s1_len = strlen (\"000000000000000000000000000000"
	.ascii	"11\"), __s1_len < 4) ? (__builtin_constant_p (f(0x3, buf, si"
	.ascii	"zeof buf)) && ((size_t)(const void *)((f(0x3, buf, sizeof bu"
	.ascii	"f)) + 1) - (size_t)(const void *)(f(0x3, buf, sizeof buf)) ="
	.ascii	"= 1) ? __builtin_strcmp (\"00000000000000000000000000000011\""
	.ascii	", f(0x3, buf, sizeof buf)) : (__extension__ ({ __const unsig"
	.ascii	"ned char *__s2 = (__const unsigned char *) (__const char *) "
	.ascii	"(f(0x3, buf, sizeof buf)); register int __result = (((__cons"
	.ascii	"t unsigned char *) (__const char *) (\"000000000000000000000"
	.ascii	"00000000011\"))[0] - __s2[0]); if (__s1_len > 0 && __result "
	.ascii	"== 0) { __result = (((__const unsigned char *) (__const char"
	.ascii	" *) (\"00000000000000000000000000000011\"))[1] - __s2[1]); i"
	.ascii	"f (__s1_len > 1 && __result == 0) { __result = (((__const un"
	.ascii	"signed char *) (__const char *) (\"0000000000000000000000000"
	.ascii	"0000011\"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0"
	.ascii	") __result = (((__const unsigned char *) (__const char *) (\""
	.ascii	"00000000000000000000000000000011\"))[3] - __s2[3]); } } __re"
	.ascii	"sult; }))) : (__builtin_constant_p (f(0x3, buf, sizeof buf))"
	.ascii	" && ((size_t)(const void *)((f(0x3, buf, sizeof buf)) + 1) -"
	.ascii	" (size_t)(const void *)(f(0x3, buf, sizeof buf"
	.ascii	")) == 1) && (__s2_len = strlen (f(0x3, buf, sizeof buf)), __"
	.ascii	"s2_len < 4) ? (__builtin_constant_p (\"000000000000000000000"
	.ascii	"00000000011\") && ((size_t)(const void *)((\"000000000000000"
	.ascii	"00000000000000011\") + 1) - (size_t)(const void *)(\"0000000"
	.ascii	"0000000000000000000000011\") == 1) ? __builtin_strcmp (\"000"
	.ascii	"00000000000000000000000000011\", f(0x3, buf, sizeof buf)) : "
	.ascii	"(__extension__ ({ __const unsigned char *__s1 = (__const uns"
	.ascii	"igned char *) (__const char *) (\"00000000000000000000000000"
	.ascii	"000011\"); register int __result = __s1[0] - ((__const unsig"
	.ascii	"ned char *) (__const char *) (f(0x3, buf, sizeof buf)))[0]; "
	.ascii	"if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ("
	.ascii	"(__const unsigned char *) (__const char *) (f(0x3, buf, size"
	.ascii	"of buf)))[1]); if (__s2_len > 1 && __result == 0) { __result"
	.ascii	" = (__s1[2] - ((__const unsigned char *) (__const char *) (f"
	.ascii	"(0x3, buf, si"
	.string	"zeof buf)))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(0x3, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"00000000000000000000000000000011\", f(0x3, buf, sizeof buf))))); })"
	.align 32
.LC6:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"00000000000000000000000000000001\") && __built"
	.ascii	"in_constant_p (f(0x1, buf, sizeof buf)) && (__s1_len = strle"
	.ascii	"n (\"00000000000000000000000000000001\"), __s2_len = strlen "
	.ascii	"(f(0x1, buf, sizeof buf)), (!((size_t)(const void *)((\"0000"
	.ascii	"0000000000000000000000000001\") + 1) - (size_t)(const void *"
	.ascii	")(\"00000000000000000000000000000001\") == 1) || __s1_len >="
	.ascii	" 4) && (!((size_t)(const void *)((f(0x1, buf, sizeof buf)) +"
	.ascii	" 1) - (size_t)(const void *)(f(0x1, buf, sizeof buf)) == 1) "
	.ascii	"|| __s2_len >= 4)) ? __builtin_strcmp (\"0000000000000000000"
	.ascii	"0000000000001\", f(0x1, buf, sizeof buf)) : (__builtin_const"
	.ascii	"ant_p (\"00000000000000000000000000000001\") && ((size_t)(co"
	.ascii	"nst void *)((\"00000000000000000000000000000001\") + 1) - (s"
	.ascii	"ize_t)(const void *)(\"00000000000000000000000000000001\") ="
	.ascii	"= 1) && (__s1_len = strlen (\"000000000000000000000000000000"
	.ascii	"01\"), __s1_len < 4) ? (__builtin_constant_p (f(0x1, buf, si"
	.ascii	"zeof buf)) && ((size_t)(const void *)((f(0x1, buf, sizeof bu"
	.ascii	"f)) + 1) - (size_t)(const void *)(f(0x1, buf, sizeof buf)) ="
	.ascii	"= 1) ? __builtin_strcmp (\"00000000000000000000000000000001\""
	.ascii	", f(0x1, buf, sizeof buf)) : (__extension__ ({ __const unsig"
	.ascii	"ned char *__s2 = (__const unsigned char *) (__const char *) "
	.ascii	"(f(0x1, buf, sizeof buf)); register int __result = (((__cons"
	.ascii	"t unsigned char *) (__const char *) (\"000000000000000000000"
	.ascii	"00000000001\"))[0] - __s2[0]); if (__s1_len > 0 && __result "
	.ascii	"== 0) { __result = (((__const unsigned char *) (__const char"
	.ascii	" *) (\"00000000000000000000000000000001\"))[1] - __s2[1]); i"
	.ascii	"f (__s1_len > 1 && __result == 0) { __result = (((__const un"
	.ascii	"signed char *) (__const char *) (\"0000000000000000000000000"
	.ascii	"0000001\"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0"
	.ascii	") __result = (((__const unsigned char *) (__const char *) (\""
	.ascii	"00000000000000000000000000000001\"))[3] - __s2[3]); } } __re"
	.ascii	"sult; }))) : (__builtin_constant_p (f(0x1, buf, sizeof buf))"
	.ascii	" && ((size_t)(const void *)((f(0x1, buf, sizeof buf)) + 1) -"
	.ascii	" (size_t)(const void *)(f(0x1, buf, sizeof buf"
	.ascii	")) == 1) && (__s2_len = strlen (f(0x1, buf, sizeof buf)), __"
	.ascii	"s2_len < 4) ? (__builtin_constant_p (\"000000000000000000000"
	.ascii	"00000000001\") && ((size_t)(const void *)((\"000000000000000"
	.ascii	"00000000000000001\") + 1) - (size_t)(const void *)(\"0000000"
	.ascii	"0000000000000000000000001\") == 1) ? __builtin_strcmp (\"000"
	.ascii	"00000000000000000000000000001\", f(0x1, buf, sizeof buf)) : "
	.ascii	"(__extension__ ({ __const unsigned char *__s1 = (__const uns"
	.ascii	"igned char *) (__const char *) (\"00000000000000000000000000"
	.ascii	"000001\"); register int __result = __s1[0] - ((__const unsig"
	.ascii	"ned char *) (__const char *) (f(0x1, buf, sizeof buf)))[0]; "
	.ascii	"if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ("
	.ascii	"(__const unsigned char *) (__const char *) (f(0x1, buf, size"
	.ascii	"of buf)))[1]); if (__s2_len > 1 && __result == 0) { __result"
	.ascii	" = (__s1[2] - ((__const unsigned char *) (__const char *) (f"
	.ascii	"(0x1, buf, si"
	.string	"zeof buf)))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(0x1, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"00000000000000000000000000000001\", f(0x1, buf, sizeof buf))))); })"
	.align 32
.LC4:
	.ascii	"0 == __extension__ ({ size_t __s1_len, __s2_len; (__builtin_"
	.ascii	"constant_p (\"00000000000000000000000000000000\") && __built"
	.ascii	"in_constant_p (f(0x0, buf, sizeof buf)) && (__s1_len = strle"
	.ascii	"n (\"00000000000000000000000000000000\"), __s2_len = strlen "
	.ascii	"(f(0x0, buf, sizeof buf)), (!((size_t)(const void *)((\"0000"
	.ascii	"0000000000000000000000000000\") + 1) - (size_t)(const void *"
	.ascii	")(\"00000000000000000000000000000000\") == 1) || __s1_len >="
	.ascii	" 4) && (!((size_t)(const void *)((f(0x0, buf, sizeof buf)) +"
	.ascii	" 1) - (size_t)(const void *)(f(0x0, buf, sizeof buf)) == 1) "
	.ascii	"|| __s2_len >= 4)) ? __builtin_strcmp (\"0000000000000000000"
	.ascii	"0000000000000\", f(0x0, buf, sizeof buf)) : (__builtin_const"
	.ascii	"ant_p (\"00000000000000000000000000000000\") && ((size_t)(co"
	.ascii	"nst void *)((\"00000000000000000000000000000000\") + 1) - (s"
	.ascii	"ize_t)(const void *)(\"00000000000000000000000000000000\") ="
	.ascii	"= 1) && (__s1_len = strlen (\"000000000000000000000000000000"
	.ascii	"00\"), __s1_len < 4) ? (__builtin_constant_p (f(0x0, buf, si"
	.ascii	"zeof buf)) && ((size_t)(const void *)((f(0x0, buf, sizeof bu"
	.ascii	"f)) + 1) - (size_t)(const void *)(f(0x0, buf, sizeof buf)) ="
	.ascii	"= 1) ? __builtin_strcmp (\"00000000000000000000000000000000\""
	.ascii	", f(0x0, buf, sizeof buf)) : (__extension__ ({ __const unsig"
	.ascii	"ned char *__s2 = (__const unsigned char *) (__const char *) "
	.ascii	"(f(0x0, buf, sizeof buf)); register int __result = (((__cons"
	.ascii	"t unsigned char *) (__const char *) (\"000000000000000000000"
	.ascii	"00000000000\"))[0] - __s2[0]); if (__s1_len > 0 && __result "
	.ascii	"== 0) { __result = (((__const unsigned char *) (__const char"
	.ascii	" *) (\"00000000000000000000000000000000\"))[1] - __s2[1]); i"
	.ascii	"f (__s1_len > 1 && __result == 0) { __result = (((__const un"
	.ascii	"signed char *) (__const char *) (\"0000000000000000000000000"
	.ascii	"0000000\"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0"
	.ascii	") __result = (((__const unsigned char *) (__const char *) (\""
	.ascii	"00000000000000000000000000000000\"))[3] - __s2[3]); } } __re"
	.ascii	"sult; }))) : (__builtin_constant_p (f(0x0, buf, sizeof buf))"
	.ascii	" && ((size_t)(const void *)((f(0x0, buf, sizeof buf)) + 1) -"
	.ascii	" (size_t)(const void *)(f(0x0, buf, sizeof buf"
	.ascii	")) == 1) && (__s2_len = strlen (f(0x0, buf, sizeof buf)), __"
	.ascii	"s2_len < 4) ? (__builtin_constant_p (\"000000000000000000000"
	.ascii	"00000000000\") && ((size_t)(const void *)((\"000000000000000"
	.ascii	"00000000000000000\") + 1) - (size_t)(const void *)(\"0000000"
	.ascii	"0000000000000000000000000\") == 1) ? __builtin_strcmp (\"000"
	.ascii	"00000000000000000000000000000\", f(0x0, buf, sizeof buf)) : "
	.ascii	"(__extension__ ({ __const unsigned char *__s1 = (__const uns"
	.ascii	"igned char *) (__const char *) (\"00000000000000000000000000"
	.ascii	"000000\"); register int __result = __s1[0] - ((__const unsig"
	.ascii	"ned char *) (__const char *) (f(0x0, buf, sizeof buf)))[0]; "
	.ascii	"if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ("
	.ascii	"(__const unsigned char *) (__const char *) (f(0x0, buf, size"
	.ascii	"of buf)))[1]); if (__s2_len > 1 && __result == 0) { __result"
	.ascii	" = (__s1[2] - ((__const unsigned char *) (__const char *) (f"
	.ascii	"(0x0, buf, si"
	.string	"zeof buf)))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (f(0x0, buf, sizeof buf)))[3]); } } __result; }))) : __builtin_strcmp (\"00000000000000000000000000000000\", f(0x0, buf, sizeof buf))))); })"
	.text
	.p2align 4,,15
	.type	test, @function
test:
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%edi
	pushl	%esi
	movl	$.LC1, %esi
	pushl	%ebx
	subl	$76, %esp
	leal	-72(%ebp), %ebx
	movl	$.LC0, (%esp)
	movl	8(%ebp), %ecx
	movl	%ecx, 4(%esp)
	call	printf
	movl	stdout, %edx
	movl	%edx, (%esp)
	call	fflush
	movl	%ebx, 4(%esp)
	movl	$36, %eax
	movl	%eax, 8(%esp)
	movl	$0, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L292
	movl	%ebx, 4(%esp)
	movl	$36, %edi
	movl	$.LC5, %esi
	movl	%edi, 8(%esp)
	movl	$1, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L293
	movl	%ebx, 4(%esp)
	movl	$36, %esi
	movl	%esi, 8(%esp)
	movl	$.LC7, %esi
	movl	$3, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L294
	movl	%ebx, 4(%esp)
	movl	$36, %esi
	movl	%esi, 8(%esp)
	movl	$.LC9, %esi
	movl	$16, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L295
	movl	%ebx, 4(%esp)
	movl	$36, %edi
	movl	$.LC11, %esi
	movl	%edi, 8(%esp)
	movl	$65536, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L296
	movl	%ebx, 4(%esp)
	movl	$36, %eax
	movl	$.LC13, %esi
	movl	%eax, 8(%esp)
	movl	$-2147483648, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L297
	movl	%ebx, 4(%esp)
	movl	$36, %esi
	movl	%esi, 8(%esp)
	movl	$.LC15, %esi
	movl	$-1, (%esp)
	call	*12(%ebp)
	cld
	movl	$33, %ecx
	movl	%eax, %edi
	repz
	cmpsb
	jne	.L298
	addl	$76, %esp
	popl	%ebx
	popl	%esi
	popl	%edi
	popl	%ebp
	ret
.L298:
	movl	$.LC16, (%esp)
	movl	$.LC2, %edi
	movl	$247, %ebx
	movl	%edi, 12(%esp)
.L291:
	movl	$.LC3, %ecx
	movl	%ebx, 8(%esp)
	movl	%ecx, 4(%esp)
.L288:
	call	__assert_fail
.L297:
	movl	$.LC14, (%esp)
	movl	$.LC2, %edx
	movl	$246, %edi
	movl	%edx, 12(%esp)
	movl	$.LC3, %ebx
	movl	%edi, 8(%esp)
.L289:
	movl	%ebx, 4(%esp)
	jmp	.L288
.L296:
	movl	$.LC12, (%esp)
	movl	$.LC2, %ecx
	movl	$245, %esi
	movl	%ecx, 12(%esp)
	movl	$.LC3, %edx
	movl	%esi, 8(%esp)
.L290:
	movl	%edx, 4(%esp)
	jmp	.L288
.L295:
	movl	$.LC10, (%esp)
	movl	$.LC2, %eax
	movl	$244, %ebx
	movl	%eax, 12(%esp)
	jmp	.L291
.L294:
	movl	$.LC8, (%esp)
	movl	$.LC2, %edx
	movl	$243, %edi
	movl	%edx, 12(%esp)
	movl	$.LC3, %eax
	movl	%edi, 8(%esp)
	movl	%eax, 4(%esp)
	jmp	.L288
.L293:
	movl	$.LC6, (%esp)
	movl	$.LC2, %ebx
	movl	$242, %ecx
	movl	%ebx, 12(%esp)
	movl	$.LC3, %edx
	movl	%ecx, 8(%esp)
	jmp	.L290
.L292:
	movl	$.LC4, (%esp)
	movl	$.LC2, %esi
	movl	$241, %eax
	movl	%esi, 12(%esp)
	movl	$.LC3, %ebx
	movl	%eax, 8(%esp)
	jmp	.L289
	.size	test, .-test
	.section	.note.GNU-stack,"",@progbits
	.ident	"GCC: (GNU) 3.3.6 (Gentoo 3.3.6, ssp-3.3.6-1.0, pie-8.7.8)"