08048100: xor��� %ebp,%ebp
08048102: pop��� %esi
08048103: mov��� %esp,%ecx
08048105: and��� $0xfffffff0,%esp
08048108: push�� %eax
08048109: push�� %esp
0804810a: push�� %edx
0804810b: push�� $0x804aa90
08048110: push�� $0x804aa30
08048115: push�� %ecx
08048116: push�� %esi
08048117: push�� $0x804994f
0804811c: call�� 0x0804a3b0 <__libc_start_main>
08048121: hlt���
08048122: nop���
08048123: nop���
08048124: push�� %ebp
08048125: mov��� %esp,%ebp
08048127: push�� %ebx
08048128: call�� 0x0804812d
0804812d: pop��� %ebx
0804812e: add��� $0x74763,%ebx
08048134: push�� %edx
08048135: mov��� 0xc(%ebx),%eax
0804813b: test�� %eax,%eax
0804813d: je���� 0x08048141
0804813f: call�� *%eax
08048141: pop��� %eax
08048142: pop��� %ebx
08048143: leave�
08048144: ret�� �
08048145: nop���
08048146: nop���
08048147: nop���
08048148: nop���
08048149: nop���
0804814a: nop���
0804814b: nop���
0804814c: nop���
0804814d: nop���
0804814e: nop���
0804814f: nop���
08048150: push�� %ebp
08048151: mov��� %esp,%ebp
08048153: push�� %eax
08048154: push�� %eax

# Possible reference to data in bss
08048155: cmpb�� $0x0,0x80bc8a0
0804815c: jne��� 0x080481a5

# Possible reference to data 'H
(UNKNOWN)'
0804815e: mov��� 0x80bb788,%eax
08048163: mov��� (%eax),%edx
08048165: test�� %edx,%edx
08048167: je���� 0x08048185
08048169: lea��� 0x0(%esi,1),%esi
08048170: add��� $0x4,%eax

# Possible reference to data 'H
(UNKNOWN)'
08048173: mov��� %eax,0x80bb788
08048178: call�� *%edx

# Possible reference to data 'H
(UNKNOWN)'
0804817a: mov��� 0x80bb788,%eax
0804817f: mov��� (%eax),%edx
08048181: test�� %edx,%edx
08048183: jne��� 0x08048170
08048185: mov��� $0x0,%eax
0804818a: test�� %eax,%eax
0804818c: je���� 0x0804819e
0804818e: sub��� $0xc,%esp
08048191: push�� $0x80b862c
08048196: call�� 0x00000000
0804819b: add��� $0x10,%esp

# Possible reference to data in bss
0804819e: movb�� $0x1,0x80bc8a0
080481a5: leave�
080481a6: ret���
080481a7: mov��� %esi,%esi
080481a9: lea��� 0x0(%edi,1),%edi
080481b0: push�� %ebp
080481b1: mov��� $0x0,%eax
080481b6: mov��� %esp,%ebp
080481b8: call�� 0x080481bd
080481bd: pop��� %edx
080481be: add��� $0x746d3,%edx
080481c4: push�� %ecx
080481c5: test�� %eax,%eax
080481c7: push�� %ecx
080481c8: je���� 0x080481df
080481ca: push�� %edx
080481cb: push�� $0x0

# Possible reference to data in bss
080481cd: push�� $0x80bc8a4
080481d2: push�� $0x80b862c
080481d7: call�� 0x00000000
080481dc: add��� $0x10,%esp
080481df: mov��� 0x80bc88c,%edx
080481e5: test�� %edx,%edx
080481e7: je���� 0x08048202
080481e9: mov��� $0x0,%eax
080481ee: test�� %eax,%eax
080481f0: je���� 0x08048202
080481f2: sub��� $0xc,%esp
080481f5: push�� $0x80bc88c
080481fa: call�� 0x00000000
080481ff: add��� $0x10,%esp
08048202: leave�
08048203: ret���
08048204: push�� %ebp
08048205: mov ���%esp,%ebp
08048207: sub��� $0x8,%esp

# Possible reference to data in bss
0804820a: movw�� $0x1,0x80bc906
08048213: sub��� $0xc,%esp

# Possible reference to data '(UNKNOWN)'
08048216: pushl� 0x80bb78c
0804821c: call�� 0x08055cc0 <__libc_close>
08048221: add��� $0x10,%esp
08048224: sub��� $0xc,%esp
08048227: push�� $0x1
08048229: call�� 0x08054570 <__sleep>
0804822e: add��� $0x10,%esp
08048231: sub��� $0xc,%esp
08048234: push�� $0x1
08048236: call�� 0x0804aef0 <exit>
0804823b: push�� %ebp
0804823c: mov��� %esp,%ebp
0804823e: sub��� $0x8,%esp
08048241: call�� 0x0804aad0 <__errno_location>
08048246: movl�� $0x0,(%eax)

# Possible reference to data in bss
0804824c: cmpw�� $0x1,0x80bc906
08048254: jbe��� 0x0804825b
08048256: call�� 0x08048204
0804825b: call�� 0x08048204
08048260: leave�
08048261: ret���
08048262: push�� %ebp
08048263: mov��� %esp,%ebp
08048265: sub��� $0x8,%esp
08048268: sub��� $0x8,%esp
0804826b: push�� $0x1
0804826d: push�� $0xe
0804826f: call�� 0x0804abc0 <__bsd_signal>
08048274: add ���$0x10,%esp
08048277: sub��� $0xc,%esp
0804827a: push�� $0x0
0804827c: call�� 0x08054550 <alarm>
08048281: add��� $0x10,%esp

# Possible reference to data in bss
08048284: cmpl�� $0x0,0x80bc8bc
0804828b: jne��� 0x08048292
0804828d: call�� 0x08048204
08048292: sub��� $0x8,%esp

# Possible reference to data in bss
08048295: pushl� 0x80bc8bc

# Possible reference to data in bss
0804829b: push�� $0x80bdc60
080482a0: call�� 0x0804ab30 <__libc_longjmp>
080482a5: push�� %ebp
080482a6: mov��� %esp,%ebp
080482a8: sub��� $0x8,%esp
080482ab: cmpl�� $0x0,0xc(%ebp)
080482af: jne��� 0x080482d9
080482b1: sub��� $0x8,%esp
080482b4: push�� $0x1
080482b6: push�� $0xe
080482b8: call�� 0x0804abc0 <__bsd_signal>
080482bd: add��� $0x10,%esp
080482c0: sub��� $0xc,%esp
080482c3: push�� $0x0
080482c5: call�� 0x08054550 <alarm>
080482ca: add��� $0x10,%esp

# Possible reference to data in bss
080482cd: movl�� $0x0,0x80bc8bc
080482d7: jmp��� 0x08048301
080482d9: sub��� $0x8,%esp
080482dc: push�� $0x8048262
080482e1: push�� $0xe
080482e3: call�� 0x0804abc0 <__bsd_signal>
080482e8: add��� $0x10,%esp
080482eb: sub��� $0xc,%esp
080482ee: pushl� 0xc(%ebp)
080482f1: call�� 0x08054550 <alarm>
080482f6: add��� $0x10,%esp
080482f9: mov��� 0x8(%ebp),%eax

# Possible reference to data in bss
080482fc: mov��� %eax,0x80bc8bc
08048301: leave�
08048302: ret���
08048303: push�� %ebp
08048304: mov��� %esp,%ebp
08048306: sub��� $0x8,%esp
08048309: mov��� 0x8(%ebp),%eax
0804830c: add��� $0x4,%eax
0804830f: and��� $0xfffffffc,%eax
08048312: mov��� %eax,0xfffffffc(%ebp)
08048315: sub��� $0xc,%esp
08048318: pushl� 0xfffffffc(%ebp)
0804831b: call�� 0x0804ec90 <__libc_malloc>
08048320: add��� $0x10,%esp
08048323: mov��� %eax,0xfffffff8(%ebp)
08048326: cmpl�� $0x0,0xfffffff8(%ebp)
0804832a: je���� 0x08048341
0804832c: sub��� $0x4,%esp
0804832f: pushl� 0xfffffffc(%ebp)
08048332: push�� $0x0
08048334: pushl� 0xfffffff8(%ebp)
08048337: call�� 0x08054220 <memset>
0804833c: add��� $0x10,%esp
0804833f: jmp��� 0x08048346
08048341: call�� 0x08048204
08048346: mov��� 0xfffffff8(%ebp),%eax
08048349: leave�
0804834a: ret���
0804834b: push�� %ebp
0804834c: mov��� %esp,%ebp
0804834e: sub��� $0xc,%esp
08048351: cmpl�� $0x0,0x8(%ebp)
08048355: jne��� 0x08048360
08048357: movl�� $0x0,0xfffffffc(%ebp)
0804835e: jmp��� 0x080483b0
08048360: cmpl�� $0x2000,0xc(%ebp)
08048367: jbe��� 0x08048372
08048369: movl�� $0x0,0xfffffffc(%ebp)
08048370: jmp��� 0x080483b0
08048372: mov��� 0xc(%ebp),%eax
08048375: mov��� %eax,0xfffffff4(%ebp)
08048378: mov��� 0x8(%ebp),%eax
0804837b: mov��� %eax,0xfffffff8(%ebp)
0804837e: cmpl�� $0x0,0xfffffff4(%ebp)
08048382: jg���� 0x08048386
08048384: jmp��� 0x080483aa
08048386: mov��� 0xfffffff8(%ebp),%eax
08048389: cmpb�� $0xa,(%eax)
0804838c: jne��� 0x080483a2
0804838e: mov��� 0xfffffff8(%ebp),%eax
08048391: sub��� 0x8(%ebp),%eax
08048394: mov��� %eax,0xfffffff4(%ebp)
08048397: incl�� 0xfffffff4(%ebp)
0804839a: mov��� 0xfffffff4(%ebp),%eax
0804839d: mov��� %eax,0xfffffffc(%ebp)
080483a0: jmp��� 0x080483b0
080483a2: incl�� 0xfffffff8(%ebp)
080483a5: decl�� 0xfffffff4(%ebp)
080483a8: jmp��� 0x0804837e
080483aa: mov��� 0xc(%ebp),%eax
080483ad: mov��� %eax,0xfffffffc(%ebp)
080483b0: mov��� 0xfffffffc(%ebp),%eax
080483b3: leave�
080483b4: ret���
080483b5: push�� %ebp
080483b6: mov��� %esp,%ebp
080483b8: sub��� $0x8,%esp
080483bb: call�� 0x0804aad0 <__errno_location>
080483c0: movl�� $0x0,(%eax)
080483c6: call�� 0x08056c00 <__h_errno_location>
080483cb: movl�� $0x0,(%eax)
080483d1: mov��� 0xc(%ebp),%eax
080483d4: sub��� $0x8,%esp
080483d7: pushl� (%eax)
080483d9: pushl� 0x8(%ebp)
080483dc: call�� 0x08054300 <__strcasecmp>
080483e1: add��� $0x10,%esp
080483e4: test�� %eax,%eax
080483e6: je���� 0x080483f1
080483e8: movl�� $0x1,0xfffffffc(%ebp)
080483ef: jmp��� 0x080483f8
080483f1: movl�� $0x0,0xfffffffc(%ebp)
080483f8: mov��� 0xfffffffc(%ebp),%eax
080483fb: leave�
080483fc: ret���
080483fd: push�� %ebp
080483fe: mov��� %esp,%ebp
08048400: sub��� $0x18,%esp
08048403: mov��� 0xc(%ebp),%eax
08048406: mov��� %ax,0xfffffffe(%ebp)
0804840a: movl�� $0x0,0xffffffec(%ebp)
08048411: call�� 0x0804aad0 <__errno_location>
08048416: movl�� $0x0,(%eax)
0804841c: call�� 0x08056c00 <__h_errno_location>
08048421: movl�� $0x0,(%eax)
08048427: cmpl�� $0x0,0x8(%ebp)
0804842b: je���� 0x08048440
0804842d: sub��� $0xc,%esp
08048430: push� �$0x1e0
08048435: call�� 0x08048303
0804843a: add��� $0x10,%esp
0804843d: mov��� %eax,0xffffffec(%ebp)
08048440: cmpl�� $0x0,0xffffffec(%ebp)
08048444: jne��� 0x0804844b
08048446: call�� 0x08048204
0804844b: sub��� $0x8,%esp

# Possible reference to data '(UNKNOWN)'
0804844e: push�� $0x80bb790
08048453: pushl� 0xffffffec(%ebp)
08048456: call�� 0x08053d40 <strcpy>
0804845b: add��� $0x10,%esp
0804845e: sub��� $0xc,%esp
08048461: pushl� 0x8(%ebp)
08048464: call�� 0x08056a70 <inet_addr>
08048469: add��� $0x10,%esp
0804846c: mov��� %eax,0xfffffff4(%ebp)
0804846f: cmpl�� $0xffffffff,0xfffffff4(%ebp)
08048473: jne��� 0x080485d1
08048479: cmpw�� $0x0,0xfffffffe(%ebp)
0804847e: je���� 0x08048485
08048480: call�� 0x08048204
08048485: sub��� $0xc,%esp
08048488: pushl� 0x8(%ebp)
0804848b: call�� 0x08056fc0 <gethostbyname>
08048490: add��� $0x10,%esp
08048493: mov��� %eax,0xfffffff8(%ebp)
08048496: cmpl�� $0x0,0xfffffff8(%ebp)
0804849a: jne��� 0x080484a1
0804849c: call�� 0x08048204
080484a1: sub��� $0x4,%esp
080484a4: push�� $0xfe
080484a9: mov��� 0xfffffff8(%ebp),%eax
080484ac: pushl� (%eax)
080484ae: pushl� 0xffffffec(%ebp)
080484b1: call�� 0x08053e90 <strncpy>
080484b6: add��� $0x10,%esp
080484b9: movl�� $0x0,0xffffffe8(%ebp)
080484c0: mov��� 0xfffffff8(%ebp),%ecx
080484c3: mov��� 0xffffffe8(%ebp),%eax
080484c6: lea��� 0x0(,%eax,4),%edx
080484cd: mov��� 0x10(%ecx),%eax
080484d0: cmpl�� $0x0,(%eax,%edx,1)
080484d4: je���� 0x0804854f
080484d6: cmpl�� $0x7,0xffffffe8(%ebp)
080484da: jle��� 0x080484de
080484dc: jmp��� 0x0804854f
080484de: sub��� $0x4,%esp
080484e1: push�� $0x4
080484e3: mov��� 0xfffffff8(%ebp),%ecx
080484e6: mov��� 0xffffffe8(%ebp),%eax
080484e9: lea��� 0x0(,%eax,4),%edx
080484f0: mov��� 0x10(%ecx),%eax
080484f3: pushl� (%eax,%edx,1)
080484f6: mov��� 0xffffffe8(%ebp),%eax
080484f9: shl��� $0x2,%eax
080484fc: add��� 0xffffffec(%ebp),%eax
080484ff: add��� $0x1c0,%eax
08048504: push�� %eax
08048505: call�� 0x080543d0 <memcpy>
0804850a: add��� $0x10,%esp
0804850d: sub��� $0x4,%esp
08048510: push�� $0x18
08048512: sub��� $0x4,%esp
08048515: mov��� 0xffffffe8(%ebp),%eax
08048518: mov��� 0xffffffec(%ebp),%edx
0804851b: pushl� 0x1c0(%edx,%eax,4)
08048522: call�� 0x08056ab0 <inet_ntoa>
08048527: add��� $0x8,%esp
0804852a: push�� %eax
0804852b: mov��� 0xffffffe8(%ebp),%eax
0804852e: add��� %eax,%eax
08048530: add��� 0xffffffe8(%ebp),%eax
08048533: shl��� $0x3,%eax
08048536: add��� 0xffffffec(%ebp),%eax
08048539: add��� $0x100,%eax
0804853e: push�� %eax
0804853f: call�� 0x08053e90 <strncpy>
08048544: add��� $0x10,%esp
08048547: incl�� 0xffffffe8(%ebp)
0804854a: jmp��� 0x080484c0

# Possible reference to data in bss
0804854f: cmpw�� $0x0,0x80bc906
08048557: jne��� 0x08048564
08048559: mov��� 0xffffffec(%ebp),%eax
0804855c: mov��� %eax,0xfffffff0(%ebp)
0804855f: jmp��� 0x080486b3
08048564: movl�� $0x0,0xffffffe8(%ebp)
0804856b: mov��� 0xffffffe8(%ebp),%edx
0804856e: mov��� 0xffffffec(%ebp),%eax
08048571: cmpl�� $0x0,0x1c0(%eax,%edx,4)
08048579: je���� 0x080486a2
0804857f: cmpl�� $0x7,0xffffffe8(%ebp)
08048583: jle��� 0x0804858a
08048585: jmp��� 0x080486a2
0804858a: sub��� $0x4,%esp
0804858d: push�� $0x2
0804858f: push�� $0x4
08048591: mov��� 0xffffffe8(%ebp),%eax
08048594: shl��� $0x2,%eax
08048597: add��� 0xffffffec(%ebp),%eax
0804859a: add��� $0x1c0,%eax
0804859f: push�� %eax
080485a0: call�� 0x08056c30 <gethostbyaddr>
080485a5: add��� $0x10,%esp
080485a8: mov��� %eax,0xfffffff8(%ebp)
080485ab: cmpl�� $0x0,0xfffffff8(%ebp)
080485af: je���� 0x080485cc
080485b1: mov��� 0xfffffff8(%ebp),%eax
080485b4: cmpl�� $0x0,(%eax)
080485b7: jne��� 0x080485bb
080485b9: jmp��� 0x080485cc
080485bb: sub��� $0x8,%esp
080485be: pushl� 0xfffffff8(%ebp)
080485c1: pushl� 0xffffffec(%ebp)
080485c4: call�� 0x080483b5
080485c9: add��� $0x10,%esp
080485cc: incl�� 0xffffffe8(%ebp)
080485cf: jmp��� 0x0804856b
080485d1: sub��� $0x4,%esp
080485d4: push�� $0x4
080485d6: lea��� 0xfffffff4(%ebp),%eax
080485d9: push�� %eax
080485da: mov��� 0xffffffec(%ebp),%eax
080485dd: add��� $0x1c0,%eax
080485e2: push�� %eax
080485e3: call�� 0x080543d0 <memcpy>
080485e8: add� ��$0x10,%esp
080485eb: sub��� $0x4,%esp
080485ee: push�� $0xc0
080485f3: sub��� $0x4,%esp
080485f6: pushl� 0xfffffff4(%ebp)
080485f9: call�� 0x08056ab0 <inet_ntoa>
080485fe: add��� $0x8,%esp
08048601: push�� %eax
08048602: mov��� 0xffffffec(%ebp),%eax
08048605: add��� $0x100,%eax
0804860a: push�� %eax
0804860b: call�� 0x08053e90 <strncpy>
08048610: add��� $0x10,%esp
08048613: cmpw�� $0x0,0xfffffffe(%ebp)
08048618: je���� 0x08048625
0804861a: mov��� 0xffffffec(%ebp),%edx
0804861d: mov��� %edx,0xfffffff0(%ebp)
08048620: jmp��� 0x080486b3

# Possible reference to data in bss
08048625: cmpw�� $0x0,0x80bc906
0804862d: jne��� 0x08048637
0804862f: mov��� 0xffffffec(%ebp),%eax
08048632: mov��� %eax,0xfffffff0(%ebp)
08048635: jmp��� 0x080486b3
08048637: sub��� $0x4,%esp
0804863a: push�� $0x2
0804863c: push�� $0x4
0804863e: lea��� 0xfffffff4(%ebp),%eax
08048641: push�� %eax
08048642: call�� 0x08056c30 <gethostbyaddr>
08048647: add��� $0x10,%esp
0804864a: mov��� %eax,0xfffffff8(%ebp)
0804864d: cmpl�� $0x0,0xfffffff8(%ebp)
08048651: jne��� 0x08048655
08048653: jmp��� 0x080486a2
08048655: sub��� $0x4,%esp
08048658: push�� $0xfe
0804865d: mov��� 0xfffffff8(%ebp),%eax
08048660: pushl� (%eax)
08048662: pushl� 0xffffffec(%ebp)
08048665: call�� 0x08053e90 <strncpy>
0804866a: add��� $0x10,%esp
0804866d: sub��� $0xc,%esp
08048670: pushl� 0xffffffec(%ebp)
08048673: call�� 0x08056fc0 <gethostbyname>
08048678: add��� $0x10,%esp
0804867b: mov��� %eax,0xfffffff8(%ebp)
0804867e: cmpl�� $0x0,0xfffffff8(%ebp)
08048682: je���� 0x080486a2
08048684: mov��� 0xfffffff8(%ebp),%eax
08048687: mov��� 0x10(%eax),%eax
0804868a: cmpl�� $0x0,(%eax)
0804868d: jne��� 0x08048691
0804868f: jmp��� 0x080486a2
08048691: sub��� $0x8,%esp
08048694: pushl� 0xfffffff8(%ebp)
08048697: pushl� 0xffffffec(%ebp)
0804869a: call�� 0x080483b5
0804869f: add��� $0x10,%esp
080486a2: call�� 0x08056c00 <__h_errno_location>
080486a7: movl�� $0x0,(%eax)
080486ad: mov��� 0xffffffec(%ebp),%edx
080486b0: mov��� %edx,0xfffffff0(%ebp)
080486b3: mov��� 0xfffffff0(%ebp),%eax
080486b6: leave�
080486b7: ret���
080486b8: push�� %ebp
080486b9: mov��� %esp,%ebp
080486bb: sub��� $0x18,%esp

# Possible reference to data 'tcp'
080486be: movl�� $0x80bb79a,0xfffffff8(%ebp)

# Possible reference to data in bss
080486c5: cmpw�� $0x0,0x80bc904
080486cd: je���� 0x080486d6

# Possible reference to data 'udp'
080486cf: movl�� $0x80bb79e,0xfffffff8(%ebp)

# Possible reference to data in bss
080486d6: mov��� 0x80bc8ec,%eax
080486db: movb�� $0x3f,(%eax)

# Possible reference to data in bss
080486de: mov ���0x80bc8ec,%eax
080486e3: movb�� $0x0,0x1(%eax)
080486e7: cmpl�� $0x0,0xc(%ebp)
080486eb: je���� 0x080487a1
080486f1: cmpl�� $0x0,0x8(%ebp)
080486f5: je���� 0x08048703
080486f7: movl�� $0x0,0xfffffff4(%ebp)
080486fe: jmp��� 0x080488a6
08048703: mov��� 0xc(%ebp),%eax
08048706: mov��� %eax,0xfffffff0(%ebp)

# Possible reference to data in bss
08048709: cmpw�� $0x0,0x80bc8fe
08048711: je���� 0x08048718
08048713: jmp��� 0x08048867
08048718: mov��� 0xfffffff0(%ebp),%eax
0804871b: and��� $0xffff,%eax
08048720: sub��� $0xc,%esp
08048723: push�� %eax
08048724: call�� 0x08056aa0 <htons>
08048729: add��� $0x10,%esp
0804872c: mov��� %eax,%edx
0804872e: and��� $0xffff,%edx
08048734: mov��� %edx,0xffffffec(%ebp)
08048737: sub��� $0x8,%esp
0804873a: pushl� 0xfffffff8(%ebp)
0804873d: pushl� 0xffffffec(%ebp)
08048740: call�� 0x08057580
08048745: add��� $0x10,%esp
08048748: mov��� %eax,0xfffffffc(%ebp)
0804874b: cmpl�� $0x0,0xfffffffc(%ebp)
0804874f: je���� 0x08048867
08048755: mov��� 0xfffffffc(%ebp),%eax
08048758: mov��� 0x8(%eax),%ax
0804875c: and��� $0xffff,%eax
08048761: sub��� $0xc,%esp
08048764: push�� %eax
08048765: call�� 0x08056aa0 <htons>
0804876a: add��� $0x10,%esp
0804876d: mov��� %eax,%edx
0804876f: and��� $0xffff,%edx
08048775: mov��� %edx,0xffffffec(%ebp)
08048778: mov��� 0xffffffec(%ebp),%eax
0804877b: cmp��� %eax,0xfffffff0(%ebp)
0804877e: je���� 0x08048867
08048784: sub��� $0x4,%esp
08048787: push�� $0x40
08048789: mov��� 0xfffffffc(%ebp),%eax
0804878c: pushl� (%eax)

# Possible reference to data in bss
0804878e: pushl� 0x80bc8ec
08048794: call�� 0x08053e90 <strncpy>
08048799: add��� $0x10,%esp
0804879c: jmp��� 0x08048867
080487a1: cmpl�� $0x0,0x8(%ebp)
080487a5: je���� 0x0804885e
080487ab: cmpl�� $0x0,0xc(%ebp)
080487af: je���� 0x080487bd
080487b1: movl�� $0x0,0xfffffff4(%ebp)
080487b8: jmp��� 0x080488a6
080487bd: sub��� $0xc,%esp
080487c0: pushl� 0x8(%ebp)
080487c3: call�� 0x0804aed0
080487c8: add��� $0x10,%esp
080487cb: mov��� %eax,0xfffffff0(%ebp)
080487ce: cmpl�� $0x0,0xfffffff0(%ebp)
080487d2: je���� 0x080487f1
080487d4: sub��� $0x8,%esp
080487d7: pushl� 0xfffffff0(%ebp)
080487da: push�� $0x0
080487dc: call�� 0x080486b8
080487e1: add��� $0x10,%esp
080487e4: and��� $0xffff,%eax
080487e9: mov��� %eax,0xfffffff4(%ebp)
080487ec: jmp��� 0x080488a6

# Possible reference to data in bss
080487f1: cmpw�� $0x0,0x80bc8fe
080487f9: je���� 0x08048807
080487fb: movl�� $0x0,0xfffffff4(%ebp)
08048802: jmp��� 0x080488a6
08048807: sub��� $0x8,%esp
0804880a: pushl� 0xfffffff8(%ebp)
0804880d: pushl� 0x8(%ebp)
08048810: call ��0x08057370
08048815: add��� $0x10,%esp
08048818: mov��� %eax,0xfffffffc(%ebp)
0804881b: cmpl�� $0x0,0xfffffffc(%ebp)
0804881f: je���� 0x0804885e
08048821: sub��� $0x4,%esp
08048824: push�� $0x40
08048826: mov��� 0xfffffffc(%ebp),%eax
08048829: pushl� (%eax)

# Possible reference to data in bss
0804882b: pushl� 0x80bc8ec
08048831: call�� 0x08053e90 <strncpy>
08048836: add��� $0x10,%esp
08048839: mov��� 0xfffffffc(%ebp),%eax
0804883c: mov��� 0x8(%eax),%ax
08048840: and��� $0xffff,%eax
08048845: sub��� $0xc,%esp
08048848: push�� %eax
08048849: call�� 0x08056aa0 <htons>
0804884e: add��� $0x10,%esp
08048851: mov��� %eax,%edx
08048853: and��� $0xffff,%edx
08048859: mov��� %edx,0xfffffff0(%ebp)
0804885c: jmp��� 0x08048867
0804885e: movl�� $0x0,0xfffffff4(%ebp)
08048865: jmp��� 0x080488a6
08048867: sub��� $0x4,%esp
0804886a: pushl� 0xfffffff0(%ebp)

# Possible reference to rodata '%d'
0804886d: push�� $0x80a44c8

# Possible reference to data in bss
08048872: mov��� 0x80bc8ec,%eax
08048877: add��� $0x40,%eax
0804887a: push�� %eax
0804887b: call�� 0x0804bf90
08048880: add��� $0x10,%esp

# Possible reference to data in bss
08048883: mov��� 0x80bc8ec,%edx
08048889: mov��� $0xffffffff,%eax
0804888e: and��� 0xfffffff0(%ebp),%eax
08048891: mov��� %ax,0x48(%edx)

# Possible reference to data in bss
08048895: mov��� 0x80bc8ec,%eax
0804889a: mov��� 0x48(%eax),%ax
0804889e: and��� $0xffff,%eax
080488a3: mov��� %eax,0xfffffff4(%ebp)
080488a6: mov��� 0xfffffff4(%ebp),%eax
080488a9: leave�
080488aa: ret���
080488ab: push�� %ebp
080488ac: mov��� %esp,%ebp
080488ae: sub��� $0x18,%esp
080488b1: movl�� $0x11170,0xfffffff4(%ebp)
080488b8: cmpl�� $0x0,0xfffffff4(%ebp)
080488bc: jne��� 0x080488c0
080488be: jmp��� 0x080488f3
080488c0: call�� 0x0804b260 <__random>
080488c5: mov��� %eax,0xfffffff8(%ebp)
080488c8: andl�� $0xffff,0xfffffff8(%ebp)
080488cf: mov��� 0x8(%ebp),%eax
080488d2: mov��� 0xfffffff8(%ebp),%edx
080488d5: cmpb�� $0x1,(%edx,%eax,1)
080488d9: jne��� 0x080488e7
080488db: mov��� 0x8(%ebp),%eax
080488de: mov��� 0xfffffff8(%ebp),%edx
080488e1: movb�� $0x2,(%edx,%eax,1)
080488e5: jmp��� 0x080488f3
080488e7: movl�� $0x0,0xfffffff8(%ebp)
080488ee: decl�� 0xfffffff4(%ebp)
080488f1: jmp��� 0x080488b8
080488f3: cmpl�� $0x0,0xfffffff8(%ebp)
080488f7: je���� 0x08048906
080488f9: mov��� 0xfffffff8(%ebp),%eax
080488fc: and��� $0xffff,%eax
08048901: mov��� %eax,0xfffffffc(%ebp)
08048904: jmp��� 0x0804894c
08048906: movl�� $0xffff,0xfffffff4(%ebp)
0804890d: cmpl�� $0x0,0xfffffff4(%ebp)
08048911: jne��� 0x08048915
08048913: jmp��� 0x08048932
08048915: mov��� 0x8(%ebp),%eax
08048918: mov��� 0xfffffff4(%ebp),%edx
0804891b: cmpb�� $0x1,(%edx,%eax,1)
0804891f: jne��� 0x0804892d
08048921: mov��� 0x8(%ebp),%eax
08048924: mov��� 0xfffffff4(%ebp),%edx
08048927: movb�� $0x2,(%edx,%eax,1)
0804892b: jmp ���0x08048932
0804892d: decl�� 0xfffffff4(%ebp)
08048930: jmp��� 0x0804890d
08048932: cmpl�� $0x0,0xfffffff4(%ebp)
08048936: je���� 0x08048945
08048938: mov��� 0xfffffff4(%ebp),%eax
0804893b: and��� $0xffff,%eax
08048940: mov��� %eax,0xfffffffc(%ebp)
08048943: jmp��� 0x0804894c
08048945: movl�� $0x0,0xfffffffc(%ebp)
0804894c: mov��� 0xfffffffc(%ebp),%eax
0804894f: leave�
08048950: ret���
08048951: push�� %ebp
08048952: mov��� %esp,%ebp
08048954: sub��� $0x8,%esp
08048957: mov��� 0xc(%ebp),%eax
0804895a: mov��� 0x10(%ebp),%edx
0804895d: mov��� %ax,0xfffffffe(%ebp)
08048961: mov��� %dx,0xfffffffc(%ebp)
08048965: cmpl�� $0x0,0x8(%ebp)
08048969: jne��� 0x08048970
0804896b: call�� 0x08048204
08048970: cmpw�� $0x0,0xfffffffe(%ebp)
08048975: je���� 0x0804897e
08048977: cmpw�� $0x0,0xfffffffc(%ebp)
0804897c: jne��� 0x08048983
0804897e: call�� 0x08048204
08048983: mov��� 0xfffffffc(%ebp),%eax
08048986: mov��� %ax,0xfffffffa(%ebp)
0804898a: mov��� 0xfffffffe(%ebp),%ax
0804898e: cmp��� 0xfffffffa(%ebp),%ax
08048992: jbe��� 0x08048996
08048994: jmp��� 0x080489b1
08048996: mov��� 0xfffffffa(%ebp),%ax
0804899a: mov��� %eax,%edx
0804899c: and��� $0xffff,%edx
080489a2: mov��� 0x8(%ebp),%eax
080489a5: movb�� $0x1,(%edx,%eax,1)
080489a9: lea��� 0xfffffffa(%ebp),%eax
080489ac: decw�� (%eax)
080489af: jmp��� 0x0804898a
080489b1: leave�
080489b2: ret���
080489b3: push�� %ebp
080489b4: mov��� %esp,%ebp
080489b6: sub��� $0x8,%esp
080489b9: sub��� $0x8,%esp
080489bc: push�� $0x0
080489be: pushl� 0x8(%ebp)
080489c1: call�� 0x08056080 <__dup2>
080489c6: add��� $0x10,%esp
080489c9: sub��� $0xc,%esp
080489cc: pushl� 0x8(%ebp)
080489cf: call�� 0x08055cc0 <__libc_close>
080489d4: add��� $0x10,%esp
080489d7: sub��� $0x8,%esp
080489da: push�� $0x1
080489dc: push�� $0x0
080489de: call�� 0x08056080 <__dup2>
080489e3: add��� $0x10,%esp
080489e6: sub��� $0x8,%esp
080489e9: push�� $0x2
080489eb: push�� $0x0
080489ed: call�� 0x08056080 <__dup2>
080489f2: add��� $0x10,%esp
080489f5: sub��� $0x8,%esp
080489f8: push�� $0x2f

# Possible reference to data in bss
080489fa: pushl� 0x80bc910
08048a00: call�� 0x08053f20 <strrchr>
08048a05: add��� $0x10,%esp
08048a08: mov��� %eax,0xfffffffc(%ebp)
08048a0b: cmpl�� $0x0,0xfffffffc(%ebp)
08048a0f: je���� 0x08048a16
08048a11: incl�� 0xfffffffc(%ebp)
08048a14: jmp��� 0x08048a1e

# Possible reference to data in bss
08048a16: mov��� 0x80bc910,%eax
08048a1b: mov��� %eax,0xfffffffc(%ebp)
08048a1e: sub��� $0x4,%esp
08048a21: push�� $0x0
08048a23: pushl� 0xfffffffc(%ebp)

# Possible reference to data in bss
08048a26: pushl� 0x80bc910
08048a2c: call�� 0x080547d0 <execl>
08048a31: add��� $0x10,%esp
08048a34: call�� 0x08048204
08048a39: leave�
08048a3a: ret���
08048a3b: push�� %ebp
08048a3c: mov��� %esp,%ebp
08048a3e: push�� %edi
08048a3f: push�� %esi
08048a40: push�� %ebx
08048a41: sub��� $0x1c,%esp
08048a44: mov��� 0xc(%ebp),%eax
08048a47: mov��� 0x14(%ebp),%edx
08048a4a: mov��� %ax,0xfffffff2(%ebp)
08048a4e: mov��� %dx,0xfffffff0(%ebp)
08048a52: call�� 0x0804aad0 <__errno_location>
08048a57: movl�� $0x0,(%eax)

# Possible reference to data in bss
08048a5d: cmpw�� $0x0,0x80bc904
08048a65: je���� 0x08048a7d
08048a67: sub��� $0x4,%esp
08048a6a: push�� $0x11
08048a6c: push�� $0x2
08048a6e: push�� $0x2
08048a70: call�� 0x08056730 <__socket>
08048a75: add��� $0x10,%esp
08048a78: mov��� %eax,0xffffffdc(%ebp)
08048a7b: jmp��� 0x08048a91
08048a7d: sub��� $0x4,%esp
08048a80: push�� $0x6
08048a82: push�� $0x1
08048a84: push�� $0x2
08048a86: call�� 0x08056730 <__socket>
08048a8b: add��� $0x10,%esp
08048a8e: mov��� %eax,0xffffffdc(%ebp)
08048a91: cmpl�� $0x0,0xffffffdc(%ebp)
08048a95: jns��� 0x08048a9c
08048a97: call�� 0x08048204
08048a9c: cmpl�� $0x0,0xffffffdc(%ebp)
08048aa0: jne��� 0x08048aa4
08048aa2: jmp��� 0x08048a5d
08048aa4: movl�� $0x1,0xffffffec(%ebp)
08048aab: sub��� $0xc,%esp
08048aae: push�� $0x4
08048ab0: lea��� 0xffffffec(%ebp),%eax
08048ab3: push�� %eax
08048ab4: push�� $0x2
08048ab6: push�� $0x1
08048ab8: pushl� 0xffffffdc(%ebp)
08048abb: call�� 0x08056710 <setsockopt>
08048ac0: add��� $0x20,%esp
08048ac3: mov��� %eax,0xffffffd8(%ebp)
08048ac6: cmpl�� $0xffffffff,0xffffffd8(%ebp)
08048aca: jne��� 0x08048ad6

# Possible reference to data in bss
08048acc: mov��� 0x80bc8dc,%eax
08048ad1: movw�� $0x2,(%eax)

# Possible reference to data in bss
08048ad6: mov��� 0x80bc8dc,%eax
08048adb: movw�� $0x2,(%eax)

# Possible reference to data in bss
08048ae0: mov��� 0x80bc8e0,%eax
08048ae5: movw�� $0x2,(%eax)
08048aea: cmpl�� $0x0,0x10(%ebp)
08048aee: je���� 0x08048b09
08048af0: sub��� $0x4,%esp
08048af3: push�� $0x4
08048af5: pushl� 0x10(%ebp)

# Possible reference to data in bss
08048af8: mov��� 0x80bc8dc,%eax
08048afd: add��� $0x4,%eax
08048b00: push�� %eax
08048b01: call�� 0x080543d0 <memcpy>
08048b06: add��� $0x10,%esp
08048b09: cmpw�� $0x0,0xfffffff0(%ebp)
08048b0e: je���� 0x08048b2e

# Possible reference to data in bss
08048b10: mov��� 0x80bc8dc,%ebx
08048b16: mov��� 0xfffffff0(%ebp),%eax
08048b19: and��� $0xffff,%eax
08048b1e: sub��� $0xc,%esp
08048b21: push�� %eax
08048b22: call�� 0x08056aa0 <htons>
08048b27: add��� $0x10,%esp
08048b2a: mov��� %ax,0x2(%ebx)
08048b2e: movl�� $0x0,0xffffffd8(%ebp)
08048b35: cmpl�� $0x0,0x10(%ebp)
08048b39: jne��� 0x08048b44
08048b3b: cmpw�� $0x0,0xfffffff0(%ebp)
08048b40: jne��� 0x08048b44
08048b42: jmp��� 0x08048baa
08048b44: mov��� 0xfffffff0(%ebp),%eax
08048b47: and��� $0xffff,%eax
08048b4c: mov��� %eax,0xffffffec(%ebp)
08048b4f: movl�� $0x4,0xffffffe8(%ebp)
08048b56: cmpl�� $0x0,0xffffffe8(%ebp)
08048b5a: jg���� 0x08048b5e
08048b5c: jmp��� 0x08048baa
08048b5e: sub��� $0x4,%esp
08048b61: push�� $0x10

# Possible reference to data in bss
08048b63: pushl� 0x80bc8dc
08048b69: pushl� 0xffffffdc(%ebp)
08048b6c: call�� 0x080565d0 <bind>
08048b71: add��� $0x10,%esp
08048b74: mov��� %eax,0xffffffd8(%ebp)
08048b77: cmpl�� $0x0,0xffffffd8(%ebp)
08048b7b: jne��� 0x08048b7f
08048b7d: jmp��� 0x08048baa
08048b7f: call�� 0x0804aad0 <__errno_location>
08048b84: cmpl�� $0x62,(%eax)
08048b87: je���� 0x08048b8b
08048b89: jmp��� 0x08048baa
08048b8b: sub��� $0xc,%esp
08048b8e: push�� $0x2
08048b90: call�� 0x08054570 <__sleep>
08048b95: add��� $0x10,%esp
08048b98: call�� 0x0804aad0 <__errno_location>
08048b9d: movl�� $0x0,(%eax)
08048ba3: lea��� 0xffffffe8(%ebp),%eax
08048ba6: decl�� (%eax)
08048ba8: jmp��� 0x08048b56
08048baa: cmpl�� $0x0,0xffffffd8(%ebp)
08048bae: je ����0x08048bb5
08048bb0: call�� 0x08048204

# Possible reference to data in bss
08048bb5: cmpw�� $0x0,0x80bc8fc
08048bbd: je���� 0x08048bca
08048bbf: mov��� 0xffffffdc(%ebp),%eax
08048bc2: mov��� %eax,0xffffffe0(%ebp)
08048bc5: jmp��� 0x08048d92
08048bca: sub��� $0x4,%esp
08048bcd: push�� $0x4
08048bcf: pushl� 0x8(%ebp)

# Possible reference to data in bss
08048bd2: mov��� 0x80bc8e0,%eax
08048bd7: add��� $0x4,%eax
08048bda: push�� %eax
08048bdb: call�� 0x080543d0 <memcpy>
08048be0: add��� $0x10,%esp

# Possible reference to data in bss
08048be3: mov��� 0x80bc8e0,%ebx
08048be9: mov��� 0xfffffff2(%ebp),%ax
08048bed: and��� $0xffff,%eax
08048bf2: sub��� $0xc,%esp
08048bf5: push�� %eax
08048bf6: call�� 0x08056aa0 <htons>
08048bfb: add��� $0x10,%esp
08048bfe: mov��� %ax,0x2(%ebx)

# Possible reference to data in bss
08048c02: cmpl�� $0x0,0x80bc8c4
08048c09: je���� 0x08048d0c

# Possible reference to data in bss
08048c0f: cmpl�� $0x0,0x80bc8e8
08048c16: jne��� 0x08048cd5
08048c1c: sub��� $0xc,%esp
08048c1f: push�� $0x30
08048c21: call�� 0x08048303
08048c26: add��� $0x10,%esp

# Possible reference to data in bss
08048c29: mov��� %eax,0x80bc8e8

# Possible reference to data in bss
08048c2e: mov��� 0x80bc8e8,%eax
08048c33: mov��� %eax,0xffffffe4(%ebp)
08048c36: mov��� 0xffffffe4(%ebp),%eax
08048c39: movb�� $0x83,(%eax)
08048c3c: lea��� 0xffffffe4(%ebp),%eax
08048c3f: incl�� (%eax)
08048c41: mov��� 0xffffffe4(%ebp),%eax
08048c44: mov��� %eax,%ecx

# Possible reference to data in bss
08048c46: mov��� 0x80bc8c4,%eax
08048c4b: shl��� $0x2,%eax
08048c4e: lea��� 0x7(%eax),%edx
08048c51: mov��� $0xff,%al
08048c53: and��� %edx,%eax
08048c55: mov��� %al,(%ecx)
08048c57: lea��� 0xffffffe4(%ebp),%eax
08048c5a: incl�� (%eax)
08048c5c: mov��� 0xffffffe4(%ebp),%eax
08048c5f: mov��� %eax,%edx

# Possible reference to data ' '
08048c61: mov��� 0x80bb7a4,%al
08048c66: mov��� %al,(%edx)
08048c68: lea��� 0xffffffe4(%ebp),%eax
08048c6b: incl�� (%eax)
08048c6d: movl�� $0x0,0xffffffec(%ebp)
08048c74: mov��� 0xffffffec(%ebp),%eax

# Possible reference to data in bss
08048c77: cmp��� 0x80bc8c4,%eax
08048c7d: jl���� 0x08048c81
08048c7f: jmp��� 0x08048cb6
08048c81: sub��� $0x4,%esp
08048c84: push�� $0x4
08048c86: mov��� 0xffffffec(%ebp),%eax
08048c89: lea��� 0x0(,%eax,4),%edx

# Possible reference to data in bss
08048c90: mov��� 0x80bc8e4,%eax
08048c95: mov��� (%eax,%edx,1),%eax
08048c98: add��� $0x1c0,%eax
08048c9d: push�� %eax
08048c9e: pushl� 0xffffffe4(%ebp)
08048ca1: call�� 0x080543d0 <memcpy>
08048ca6: add��� $0x10,%esp
08048ca9: lea��� 0xffffffe4(%ebp),%eax
08048cac: addl�� $0x4,(%eax)
08048caf: lea��� 0xffffffec(%ebp),%eax
08048cb2: incl�� (%eax)
08048cb4: jmp��� 0x08048c74
08048cb6: sub��� $0x4,%esp
08048cb9: push�� $0x4
08048cbb: pushl� 0x8(%ebp)
08048cbe: pushl� 0xffffffe4(%ebp)
08048cc1: call�� 0x080543d0 <memcpy>
08048cc6: add��� $0x10,%esp
08048cc9: lea��� 0xffffffe4(%ebp),%eax
08048ccc: addl�� $0x4,(%eax)
08048ccf: mov��� 0xffffffe4(%ebp),%eax
08048cd2: movb�� $0x1,(%eax)

# Possible reference to data in bss
08048cd5: mov��� 0x80bc8c4,%eax
08048cda: shl��� $0x2,%eax
08048cdd: add��� $0x8,%eax
08048ce0: mov��� %eax,0xffffffec(%ebp)
08048ce3: sub��� $0xc,%esp
08048ce6: pushl� 0xffffffec(%ebp)

# Possible reference to data in bss
08048ce9: pushl� 0x80bc8e8
08048cef: push�� $0x4
08048cf1: push�� $0x0
08048cf3: pushl� 0xffffffdc(%ebp)
08048cf6: call�� 0x08056710 <setsockopt>
08048cfb: add��� $0x20,%esp
08048cfe: mov��� %eax,0xffffffd8(%ebp)
08048d01: cmpl�� $0xffffffff,0xffffffd8(%ebp)
08048d05: jne��� 0x08048d0c
08048d07: call�� 0x08048204
08048d0c: sub��� $0x8,%esp

# Possible reference to data in bss
08048d0f: pushl� 0x80bc908
08048d15: push�� $0x1
08048d17: call�� 0x080482a5
08048d1c: add��� $0x10,%esp
08048d1f: sub��� $0xc,%esp

# Possible reference to data in bss
08048d22: push�� $0x80bdc60
08048d27: call�� 0x0804ab00 <_setjmp>
08048d2c: add��� $0x10,%esp
08048d2f: test�� %eax,%eax
08048d31: jne��� 0x08048d4e
08048d33: sub��� $0x4,%esp
08048d36: push�� $0x10

# Possible reference to data in bss
08048d38: pushl� 0x80bc8e0
08048d3e: pushl� 0xffffffdc(%ebp)
08048d41: call�� 0x080565f0 <__connect_internal>
08048d46: add��� $0x10,%esp
08048d49: mov��� %eax,0xffffffd8(%ebp)
08048d4c: jmp��� 0x08048d60
08048d4e: movl�� $0xffffffff,0xffffffd8(%ebp)
08048d55: call�� 0x0804aad0 <__errno_location>
08048d5a: movl�� $0x6e,(%eax)
08048d60: sub��� $0x8,%esp
08048d63: push�� $0x0
08048d65: push�� $0x0
08048d67: call�� 0x080482a5
08048d6c: add��� $0x10,%esp
08048d6f: cmpl�� $0x0,0xffffffd8(%ebp)
08048d73: jne��� 0x08048d7d
08048d75: mov��� 0xffffffdc(%ebp),%eax
08048d78: mov��� %eax,0xffffffe0(%ebp)
08048d7b: jmp��� 0x08048d92
08048d7d: sub��� $0xc,%esp
08048d80: pushl� 0xffffffdc(%ebp)
08048d83: call�� 0x08055cc0 <__libc_close>
08048d88: add��� $0x10,%esp
08048d8b: movl�� $0xffffffff,0xffffffe0(%ebp)
08048d92: mov��� 0xffffffe0(%ebp),%eax
08048d95: lea��� 0xfffffff4(%ebp),%esp
08048d98: pop��� %ebx
08048d99: pop��� %esi
08048d9a: pop��� %edi
08048d9b: pop��� %ebp
08048d9c: ret���
08048d9d: push�� %ebp
08048d9e: mov��� %esp,%ebp
08048da0: push�� %edi
08048da1: push�� %esi
08048da2: push�� %ebx
08048da3: sub��� $0x2c,%esp
08048da6: mov��� 0xc(%ebp),%eax
08048da9: mov��� 0x14(%ebp),%edx
08048dac: mov��� %ax,0xfffffff2(%ebp)
08048db0: mov��� %dx,0xfffffff0(%ebp)
08048db4: movl�� $0x0,0xffffffec(%ebp)
08048dbb: call�� 0x0804aad0 <__errno_location>
08048dc0: movl�� $0x0,(%eax)
08048dc6: mov��� 0xfffffff0(%ebp),%eax
08048dc9: and��� $0xffff,%eax
08048dce: push�� %eax
08048dcf: pushl� 0x10(%ebp)
08048dd2: mov��� 0xfffffff2(%ebp),%ax
08048dd6: and��� $0xffff,%eax
08048ddb: push�� %eax
08048ddc: pushl� 0x8(%ebp)
08048ddf: call�� 0x08048a3b
08048de4: add��� $0x10,%esp
08048de7: mov��� %eax,0xffffffcc(%ebp)
08048dea: cmpl�� $0x0,0xffffffcc(%ebp)
08048dee: jg���� 0x08048dfc
08048df0: movl�� $0xffffffff,0xffffffd0(%ebp)
08048df7: jmp��� 0x0804922a

# Possible reference to data in bss
08048dfc: cmpw�� $0x0,0x80bc904
08048e04: je���� 0x08048e14
08048e06: cmpw�� $0x0,0xfffffff0(%ebp)
08048e0b: jne��� 0x08048e32
08048e0d: call�� 0x08048204
08048e12: jmp��� 0x08048e32
08048e14: sub��� $0x8,%esp
08048e17: push�� $0x1
08048e19: pushl� 0xffffffcc(%ebp)
08048e1c: call�� 0x08056690 <listen>
08048e21: add��� $0x10,%esp
08048e24: mov��� %eax,0xffffffc8(%ebp)
08048e27: cmpl�� $0x0,0xffffffc8(%ebp)
08048e2b: jns��� 0x08048e32
08048e2d: call�� 0x08048204

# Possible reference to data in bss
08048e32: cmpw�� $0x0,0x80bc906
08048e3a: je���� 0x08048efa
08048e40: movl�� $0x10,0xffffffe8(%ebp)
08048e47: sub��� $0x4,%esp
08048e4a: lea��� 0xffffffe8(%ebp),%eax
08048e4d: push�� %eax

# Possible reference to data in bss
08048e4e: pushl� 0x80bc8dc
08048e54: pushl� 0xffffffcc(%ebp)
08048e57: call�� 0x08056650 <getsockname>
08048e5c: add��� $0x10,%esp
08048e5f: mov��� %eax,0xffffffc8(%ebp)
08048e62: cmpl�� $0x0,0xffffffc8(%ebp)
08048e66: jns��� 0x08048e7e
08048e68: sub��� $0x8,%esp

# Possible reference to rodata 'listening on ['
08048e6b: push�� $0x80a44cb

# Possible reference to data in bss
08048e70: pushl� 0x80bdc44
08048e76: call�� 0x08053d40 <strcpy>
08048e7b: add��� $0x10,%esp

# Possible reference to data in bss
08048e7e: mov��� 0x80bc8dc,%eax
08048e83: cmpl�� $0x0,0x4(%eax)
08048e87: je���� 0x08048eb0
08048e89: sub��� $0x8,%esp
08048e8c: sub��� $0x4,%esp

# Possible reference to data in bss
08048e8f: mov��� 0x80bc8dc,%eax
08048e94: pushl� 0x4(%eax)
08048e97: call�� 0x08056ab0 <inet_ntoa>
08048e9c: add��� $0x8,%esp
08048e9f: push�� %eax

# Possible reference to data in bss
08048ea0: pushl� 0x80bdc44
08048ea6: call�� 0x080539c0 <strcat>
08048eab: add��� $0x10,%esp
08048eae: jmp��� 0x08048ec6
08048eb0: sub��� $0x8,%esp

# Possible reference to rodata 'any'
08048eb3: push�� $0x80a44da

# Possible reference to data in bss
08048eb8: pushl� 0x80bdc44
08048ebe: call�� 0x080539c0 <strcat>
08048ec3: add��� $0x10,%esp
08048ec6: sub��� $0x8,%esp

# Possible reference to rodata '] %d ...'
08048ec9: push�� $0x80a44de

# Possible reference to data in bss
08048ece: pushl� 0x80bdc44
08048ed4: call�� 0x080539c0 <strcat>
08048ed9: add��� $0x10,%esp

# Possible reference to data in bss
08048edc: mov��� 0x80bc8dc,%eax
08048ee1: mov��� 0x2(%eax),%ax
08048ee5: and��� $0xffff,%eax
08048eea: sub��� $0xc,%esp
08048eed: push�� %eax
08048eee: call�� 0x08056aa0 <htons>
08048ef3: add��� $0x10,%esp
08048ef6: mov��� %ax,0xffffffe2(%ebp)

# Possible reference to data in bss
08048efa: cmpw�� $0x0,0x80bc904
08048f02: je���� 0x08048f89
08048f08: movl�� $0x10,0xffffffe8(%ebp)
08048f0f: sub��� $0x8,%esp

# Possible reference to data in bss
08048f12: pushl� 0x80bc908
08048f18: push�� $0x2
08048f1a: call�� 0x080482a5
08048f1f: add��� $0x10,%esp
08048f22: sub��� $0xc,%esp

# Possible reference to data in bss
08048f25: push�� $0x80bdc60
08048f2a: call�� 0x0804ab00 <_setjmp>
08048f2f: add��� $0x10,%esp
08048f32: test�� %eax,%eax
08048f34: jne��� 0x0804920a
08048f3a: sub��� $0x8,%esp
08048f3d: lea��� 0xffffffe8(%ebp),%eax
08048f40: push�� %eax

# Possible reference to data in bss
08048f41: pushl� 0x80bc8e0
08048f47: push�� $0x2
08048f49: push�� $0x2000

# Possible reference to data in bss
08048f4e: pushl� 0x80bdc44
08048f54: pushl� 0xffffffcc(%ebp)
08048f57: call�� 0x080566b0 <__libc_recvfrom>
08048f5c: add��� $0x20,%esp
08048f5f: sub��� $0x8,%esp
08048f62: push�� $0x0
08048f64: push�� $0x0
08048f66: call�� 0x080482a5
08048f6b: add��� $0x10,%esp
08048f6e: sub��� $0x4,%esp
08048f71: push�� $0x10

# Possible reference to data in bss
08048f73: pushl� 0x80bc8e0
08048f79: pushl� 0xffffffcc(%ebp)
08048f7c: call�� 0x080565f0 <__connect_internal>
08048f81: add��� $0x10,%esp
08048f84: mov��� %eax,0xffffffc8(%ebp)
08048f87: jmp��� 0x08048ff9
08048f89: movl�� $0x10,0xffffffe8(%ebp)
08048f90: sub��� $0x8,%esp

# Possible reference to data in bss
08048f93: pushl� 0x80bc908
08048f99: push�� $0x2
08048f9b: call�� 0x080482a5
08048fa0: add��� $0x10,%esp
08048fa3: sub��� $0xc,%esp

# Possible reference to data in bss
08048fa6: push�� $0x80bdc60
08048fab: call�� 0x0804ab00 <_setjmp>
08048fb0: add��� $0x10,%esp
08048fb3: test�� %eax,%eax
08048fb5: jne��� 0x0804920a
08048fbb: sub��� $0x4,%esp
08048fbe: lea��� 0xffffffe8(%ebp),%eax
08048fc1: push�� %eax

# Possible reference to data in bss
08048fc2: pushl� 0x80bc8e0
08048fc8: pushl� 0xffffffcc(%ebp)
08048fcb: call�� 0x08056570 <__libc_accept>
08048fd0: add��� $0x10,%esp
08048fd3: mov��� %eax,0xffffffc8(%ebp)
08048fd6: sub��� $0x8,%esp
08048fd9: push�� $0x0
08048fdb: push�� $0x0
08048fdd: call�� 0x080482a5
08048fe2: add��� $0x10,%esp
08048fe5: sub��� $0xc,%esp
08048fe8: pushl� 0xffffffcc(%ebp)
08048feb: call�� 0x08055cc0 <__libc_close>
08048ff0: add��� $0x10,%esp
08048ff3: mov��� 0xffffffc8(%ebp),%eax
08048ff6: mov��� %eax,0xffffffcc(%ebp)
08048ff9: cmpl�� $0x0,0xffffffc8(%ebp)
08048ffd: jns��� 0x08049004
08048fff: jmp��� 0x08049215

# Possible reference to data in bss
08049004: cmpw�� $0x0,0x80bc906
0804900c: jne��� 0x08049013
0804900e: jmp��� 0x080490d6
08049013: sub��� $0xc,%esp
08049016: push�� $0x28
08049018: call�� 0x08048303
0804901d: add��� $0x10,%esp

# Possible reference to data in bss
08049020: mov��� %eax,0x80bc8e8
08049025: movl�� $0x28,0xffffffe8(%ebp)
0804902c: sub��� $0xc,%esp
0804902f: lea��� 0xffffffe8(%ebp),%eax
08049032: push�� %eax

# Possible reference to data in bss
08049033: pushl� 0x80bc8e8
08049039: push�� $0x4
0804903b: push�� $0x0
0804903d: pushl� 0xffffffcc(%ebp)
08049040: call�� 0x08056670 <__getsockopt>
08049045: add��� $0x20,%esp
08049048: mov��� %eax,0xffffffc8(%ebp)
0804904b: cmpl�� $0x0,0xffffffc8(%ebp)
0804904f: jns��� 0x080490d6
08049055: cmpl�� $0x0,0xffffffe8(%ebp)
08049059: je���� 0x080490d6

# Possible reference to data in bss
0804905b: mov��� 0x80bc8e8,%eax
08049060: mov��� %eax,0xffffffdc(%ebp)

# Possible reference to data in bss
08049063: mov��� 0x80bdc44,%eax
08049068: mov��� %eax,0xffffffd8(%ebp)

# Possible reference to data in bss
0804906b: mov��� 0x80bdc44,%eax
08049070: sub��� $0xffffff80,%eax
08049073: mov��� %eax,0xffffffd4(%ebp)
08049076: sub��� $0x4,%esp
08049079: push�� $0x100
0804907e: push�� $0x0

# Possible reference to data in bss
08049080: pushl� 0x80bdc44
08049086: call�� 0x08054220 <memset>
0804908b: add��� $0x10,%esp
0804908e: cmpl�� $0x0,0xffffffe8(%ebp)
08049092: jg� ���0x08049096
08049094: jmp��� 0x080490d6
08049096: sub��� $0x4,%esp
08049099: mov��� 0xffffffdc(%ebp),%eax
0804909c: mov��� (%eax),%al
0804909e: and��� $0xff,%eax
080490a3: push�� %eax

# Possible reference to rodata '%2.2x '
080490a4: push�� $0x80a44e7
080490a9: pushl� 0xffffffd4(%ebp)
080490ac: call�� 0x0804bf90
080490b1: add��� $0x10,%esp
080490b4: sub��� $0x8,%esp
080490b7: pushl� 0xffffffd4(%ebp)
080490ba: pushl� 0xffffffd8(%ebp)
080490bd: call�� 0x080539c0 <strcat>
080490c2: add��� $0x10,%esp
080490c5: lea��� 0xffffffdc(%ebp),%eax
080490c8: incl�� (%eax)
080490ca: lea��� 0xffffffd8(%ebp),%eax
080490cd: incl�� (%eax)
080490cf: lea��� 0xffffffe8(%ebp),%eax
080490d2: decl�� (%eax)
080490d4: jmp��� 0x0804908e
080490d6: sub��� $0x4,%esp
080490d9: push�� $0x40
080490db: push�� $0x0

# Possible reference to data in bss
080490dd: pushl� 0x80bdc44
080490e3: call�� 0x08054220 <memset>
080490e8: add��� $0x10,%esp

# Possible reference to data in bss
080490eb: mov��� 0x80bdc44,%eax
080490f0: add��� $0x20,%eax
080490f3: mov��� %eax,0xffffffe4(%ebp)
080490f6: movl�� $0x10,0xffffffe8(%ebp)
080490fd: sub��� $0x4,%esp
08049100: lea��� 0xffffffe8(%ebp),%eax
08049103: push�� %eax

# Possible reference to data in bss
08049104: pushl� 0x80bc8dc
0804910a: pushl� 0xffffffcc(%ebp)
0804910d: call�� 0x08056650 <getsockname>
08049112: add��� $0x10,%esp
08049115: mov��� %eax,0xffffffc8(%ebp)
08049118: cmpl�� $0x0,0xffffffc8(%ebp)
0804911c: jns��� 0x08049140
0804911e: sub��� $0x8,%esp
08049121: sub��� $0x4,%esp

# Possible reference to data in bss
08049124: mov��� 0x80bc8dc,%eax
08049129: pushl� 0x4(%eax)
0804912c: call�� 0x08056ab0 <inet_ntoa>
08049131: add��� $0x8,%esp
08049134: push�� %eax
08049135: pushl� 0xffffffe4(%ebp)
08049138: call�� 0x08053d40 <strcpy>
0804913d: add��� $0x10,%esp

# Possible reference to data in bss
08049140: mov��� 0x80bc8e0,%eax
08049145: mov��� 0x2(%eax),%ax
08049149: and��� $0xffff,%eax
0804914e: sub��� $0xc,%esp
08049151: push�� %eax
08049152: call�� 0x08056aa0 <htons>
08049157: add��� $0x10,%esp
0804915a: mov��� %ax,0xffffffe2(%ebp)
0804915e: sub��� $0x8,%esp
08049161: sub��� $0x4,%esp

# Possible reference to data in bss
08049164: mov��� 0x80bc8e0,%eax
08049169: pushl� 0x4(%eax)
0804916c: call�� 0x08056ab0 <inet_ntoa>
08049171: add��� $0x8,%esp
08049174: push�� %eax

# Possible reference to data in bss
08049175: pushl� 0x80bdc44
0804917b: call�� 0x08053d40 <strcpy>
08049180: add��� $0x10,%esp
08049183: sub��� $0x8,%esp

# Possible reference to data in bss
08049186: mov��� 0x80bc8fe,%ax
0804918c: and��� $0xffff,%eax
08049191: push�� %eax

# Possible reference to data in bss
08049192: pushl� 0x80bdc44
08049198: call�� 0x080483fd
0804919d: add��� $0x10,%esp
080491a0: mov��� %eax,0xffffffec(%ebp)
080491a3: call�� 0x0804aad0 <__errno_location>
080491a8: movl ��$0x0,(%eax)
080491ae: movl�� $0x0,0xffffffe8(%ebp)
080491b5: cmpl�� $0x0,0x8(%ebp)
080491b9: je���� 0x080491df
080491bb: mov��� 0xffffffec(%ebp),%eax
080491be: add��� $0x1c0,%eax
080491c3: sub��� $0x4,%esp
080491c6: push�� $0x10
080491c8: push�� %eax
080491c9: pushl� 0x8(%ebp)
080491cc: call�� 0x080540e0 <memcmp>
080491d1: add��� $0x10,%esp
080491d4: test�� %eax,%eax
080491d6: je���� 0x080491df
080491d8: movl�� $0x1,0xffffffe8(%ebp)
080491df: cmpw�� $0x0,0xfffffff2(%ebp)
080491e4: je���� 0x080491f7
080491e6: mov��� 0xffffffe2(%ebp),%ax
080491ea: cmp��� 0xfffffff2(%ebp),%ax
080491ee: je���� 0x080491f7
080491f0: movl�� $0x1,0xffffffe8(%ebp)
080491f7: cmpl�� $0x0,0xffffffe8(%ebp)
080491fb: je���� 0x08049202
080491fd: call�� 0x08048204
08049202: mov��� 0xffffffcc(%ebp),%eax
08049205: mov��� %eax,0xffffffd0(%ebp)
08049208: jmp��� 0x0804922a
0804920a: call�� 0x0804aad0 <__errno_location>
0804920f: movl�� $0x6e,(%eax)
08049215: sub��� $0xc,%esp
08049218: pushl� 0xffffffcc(%ebp)
0804921b: call�� 0x08055cc0 <__libc_close>
08049220: add��� $0x10,%esp
08049223: movl�� $0xffffffff,0xffffffd0(%ebp)
0804922a: mov��� 0xffffffd0(%ebp),%eax
0804922d: lea��� 0xfffffff4(%ebp),%esp
08049230: pop��� %ebx
08049231: pop��� %esi
08049232: pop��� %edi
08049233: pop��� %ebp
08049234: ret���
08049235: push�� %ebp
08049236: mov��� %esp,%ebp
08049238: sub��� $0x8,%esp
0804923b: sub��� $0x4,%esp
0804923e: push�� $0x1

# Possible reference to data in bss
08049240: pushl� 0x80bdd00
08049246: pushl� 0x8(%ebp)
08049249: call�� 0x08055d70 <__libc_write>
0804924e: add��� $0x10,%esp
08049251: mov��� %eax,0xfffffff8(%ebp)
08049254: cmpl�� $0x1,0xfffffff8(%ebp)
08049258: je���� 0x080492c5

# Possible reference to data in bss
0804925a: cmpl�� $0x0,0x80bc908
08049261: je���� 0x08049276
08049263: sub��� $0xc,%esp

# Possible reference to data in bss
08049266: pushl� 0x80bc908
0804926c: call�� 0x08054570 <__sleep>
08049271: add��� $0x10,%esp
08049274: jmp��� 0x080492c5

# Possible reference to data in bss
08049276: movw�� $0x0,0x80bc904

# Possible reference to data in bss
0804927f: movl�� $0x5,0x80bc908
08049289: push�� $0x0
0804928b: push�� $0x0
0804928d: push�� $0x7a69
08049292: pushl� 0xc(%ebp)
08049295: call�� 0x08048a3b
0804929a: add��� $0x10,%esp
0804929d: mov��� %eax,0xfffffff8(%ebp)
080492a0: cmpl�� $0x0,0xfffffff8(%ebp)
080492a4: jle��� 0x080492b4
080492a6: sub��� $0xc,%esp
080492a9: pushl� 0xfffffff8(%ebp)
080492ac: call�� 0x08055cc0 <__libc_close>
080492b1: add��� $0x10,%esp

# Possible reference to data in bss
080492b4: movl�� $0x0,0x80bc908

# Possible reference to data in bss
080492be: incw�� 0x80bc904
080492c5: call�� 0x0804aad0 <__errno_location>
080492ca: movl�� $0x0,(%eax)
080492d0: sub��� $0x4,%esp
080492d3: push�� $0x1

# Possible reference to data in bss
080492d5: pushl� 0x80bdd00
080492db: pushl� 0x8(%ebp)
080492de: call�� 0x08055d70 <__libc_write>
080492e3: add��� $0x10,%esp
080492e6: mov��� %eax,0xfffffff8(%ebp)
080492e9: cmpl�� $0x1,0xfffffff8(%ebp)
080492ed: jne��� 0x080492f7
080492ef: mov��� 0x8(%ebp),%eax
080492f2: mov��� %eax,0xfffffffc(%ebp)
080492f5: jmp��� 0x0804930c
080492f7: sub��� $0xc,%esp
080492fa: pushl� 0x8(%ebp)
080492fd: call�� 0x08055cc0 <__libc_close>
08049302: add��� $0x10,%esp
08049305: movl�� $0xffffffff,0xfffffffc(%ebp)
0804930c: mov��� 0xfffffffc(%ebp),%eax
0804930f: leave�
08049310: ret���
08049311: push�� %ebp
08049312: mov��� %esp,%ebp
08049314: sub��� $0x28,%esp

# Possible reference to data in bss
08049317: cmpl�� $0x0,0x80bc8c0
0804931e: jne��� 0x08049325
08049320: call�� 0x08048204
08049325: cmpl�� $0x0,0x10(%ebp)
08049329: jne��� 0x08049330
0804932b: jmp��� 0x08049509

# Possible reference to data in bss
08049330: mov��� 0x80bc8f0,%eax
08049335: mov��� %eax,0xffffffec(%ebp)
08049338: cmpl�� $0x0,0x8(%ebp)
0804933c: je���� 0x0804934e
0804933e: mov��� 0xffffffec(%ebp),%edx
08049341: movb�� $0x3c,(%edx)

# Possible reference to data in bss
08049344: mov��� 0x80bc8cc,%eax
08049349: mov��� %eax,0xfffffff8(%ebp)
0804934c: jmp��� 0x0804935c
0804934e: mov��� 0xffffffec(%ebp),%eax
08049351: movb�� $0x3e,(%eax)

# Possible reference to data in bss
08049354: mov��� 0x80bc8d0,%eax
08049359: mov��� %eax,0xfffffff8(%ebp)
0804935c: incl�� 0xffffffec(%ebp)
0804935f: mov��� 0xffffffec(%ebp),%edx
08049362: movb�� $0x20,(%edx)
08049365: mov��� 0xc(%ebp),%eax
08049368: mov��� %eax,0xfffffff0(%ebp)
0804936b: mov��� 0x10(%ebp),%eax
0804936e: mov��� %eax,0xfffffffc(%ebp)

# Possible reference to data in bss
08049371: mov��� 0x80bc8f0,%eax
08049376: add��� $0x3b,%eax
08049379: movb�� $0x23,(%eax)

# Possible reference to data in bss
0804937c: mov��� 0x80bc8f0,%eax
08049381: add��� $0x3c,%eax
08049384: movb�� $0x20,(%eax)
08049387: cmpl�� $0x0,0xfffffffc(%ebp)
0804938b: jne��� 0x08049392
0804938d: jmp��� 0x08049509
08049392: movl�� $0x10,0xffffffe4(%ebp)
08049399: movl�� $0x4e,0xfffffff4(%ebp)
080493a0: mov��� 0xffffffe4(%ebp),%edx
080493a3: cmp��� %edx,0xfffffffc(%ebp)
080493a6: jge��� 0x08049409
080493a8: mov��� 0xfffffffc(%ebp),%eax
080493ab: add��� 0xfffffff4(%ebp),%eax
080493ae: sub��� $0x10,%eax
080493b1: mov��� %eax,0xfffffff4(%ebp)
080493b4: mov��� 0xfffffffc(%ebp),%edx
080493b7: mov��� %edx,%eax
080493b9: add��� %eax,%eax
080493bb: add��� %edx,%eax
080493bd: mov��� %eax,0xffffffe4(%ebp)
080493c0: addl�� $0xb,0xffffffe4(%ebp)
080493c4: mov��� 0xffffffe4(%ebp),%eax

# Possible reference to data in bss
080493c7: add��� 0x80bc8f0,%eax
080493cd: mov��� %eax,0xffffffec(%ebp)
080493d0: mov��� $0x10,%eax
080493d5: sub��� 0xfffffffc(%ebp),%eax
080493d8: mov��� %eax,0xffffffe4(%ebp)
080493db: cmpl�� $0x0,0xffffffe4(%ebp)
080493df: jne��� 0x080493e3
080493e1: jmp��� 0x08049403
080493e3: mov��� 0xffffffec(%ebp),%eax
080493e6: movb�� $0x20,(%eax)
080493e9: incl�� 0xffffffec(%ebp)
080493ec: mov��� 0xffffffec(%ebp),%eax
080493ef: movb�� $0x20,(%eax)
080493f2: incl�� 0xffffffec(%ebp)
080493f5: mov��� 0xffffffec(%ebp),%eax
080493f8: movb�� $0x20,(%eax)
080493fb: incl�� 0xffffffec(%ebp)
080493fe: decl�� 0xffffffe4(%ebp)
08049401: jmp��� 0x080493db
08049403: mov��� 0xfffffffc(%ebp),%edx
08049406: mov��� %edx,0xffffffe4(%ebp)
08049409: lea��� 0xfffffffc(%ebp),%eax
0804940c: mov��� 0xffffffe4(%ebp),%edx
0804940f: sub��� %edx,(%eax)
08049411: sub��� $0x4,%esp
08049414: pushl� 0xfffffff8(%ebp)

# Possible reference to rodata '%8.8x '
08049417: push�� $0x80a44ee

# Possible reference to data in bss
0804941c: mov��� 0x80bc8f0,%eax
08049421: add��� $0x2,%eax
08049424: push�� %eax
08049425: call�� 0x0804bf90
0804942a: add��� $0x10,%esp
0804942d: lea��� 0xfffffff8(%ebp),%eax
08049430: mov��� 0xffffffe4(%ebp),%edx
08049433: add��� %edx,(%eax)

# Possible reference to data in bss
08049435: mov��� 0x80bc8f0,%eax
0804943a: add��� $0xb,%eax
0804943d: mov��� %eax,0xffffffec(%ebp)

# Possible reference to data in bss
08049440: mov��� 0x80bc8f0,%edx
08049446: add��� $0x3d,%edx
08049449: mov��� %edx,0xffffffe8(%ebp)
0804944c: cmpl�� $0x0,0xffffffe4(%ebp)
08049450: jne��� 0x08049454
08049452: jmp��� 0x080494d2
08049454: mov��� 0xfffffff0(%ebp),%edx
08049457: mov��� (%edx),%al
08049459: shr��� $0x4,%al
0804945c: mov��� $0x0,%edx
08049461: mov��� %al,%dl
08049463: mov ���%edx,0xffffffe0(%ebp)
08049466: mov��� 0xffffffe0(%ebp),%edx

# Possible reference to data '0123456789abcdef� '
08049469: mov��� 0x80bb7bc(%edx),%al
0804946f: mov��� 0xffffffec(%ebp),%edx
08049472: mov��� %al,(%edx)
08049474: incl�� 0xffffffec(%ebp)
08049477: mov��� 0xfffffff0(%ebp),%edx
0804947a: mov��� $0x0,%eax
0804947f: mov��� (%edx),%al
08049481: mov��� %eax,0xffffffe0(%ebp)
08049484: andl�� $0xf,0xffffffe0(%ebp)
08049488: mov��� 0xffffffe0(%ebp),%edx

# Possible reference to data '0123456789abcdef �'
0804948b: mov��� 0x80bb7bc(%edx),%al
08049491: mov��� 0xffffffec(%ebp),%edx
08049494: mov��� %al,(%edx)
08049496: incl�� 0xffffffec(%ebp)
08049499: mov��� 0xffffffec(%ebp),%eax
0804949c: movb�� $0x20,(%eax)
0804949f: incl�� 0xffffffec(%ebp)
080494a2: mov��� 0xfffffff0(%ebp),%edx
080494a5: cmpb�� $0x1f,(%edx)
080494a8: jbe��� 0x080494be
080494aa: mov��� 0xfffffff0(%ebp),%eax
080494ad: cmpb�� $0x7e,(%eax)
080494b0: ja���� 0x080494be
080494b2: mov��� 0xfffffff0(%ebp),%edx
080494b5: mov��� (%edx),%al
080494b7: mov��� 0xffffffe8(%ebp),%edx
080494ba: mov��� %al,(%edx)
080494bc: jmp��� 0x080494c4
080494be: mov��� 0xffffffe8(%ebp),%eax
080494c1: movb�� $0x2e,(%eax)
080494c4: incl�� 0xffffffe8(%ebp)
080494c7: incl�� 0xfffffff0(%ebp)
080494ca: decl�� 0xffffffe4(%ebp)
080494cd: jmp��� 0x0804944c
080494d2: mov��� 0xffffffe8(%ebp),%edx
080494d5: movb�� $0xa,(%edx)
080494d8: sub��� $0x4,%esp
080494db: pushl� 0xfffffff4(%ebp)

# Possible reference to data in bss
080494de: pushl� 0x80bc8f0

# Possible reference to data in bss
080494e4: pushl� 0x80bc8c0
080494ea: call�� 0x08055d70 <__libc_write>
080494ef: add��� $0x10,%esp
080494f2: mov��� %eax,0xffffffe4(%ebp)
080494f5: cmpl�� $0x0,0xffffffe4(%ebp)
080494f9: jns��� 0x08049387
080494ff: call�� 0x08048204
08049504: jmp��� 0x08049387
08049509: leave�
0804950a: ret���
0804950b: push�� %ebp
0804950c: mov��� %esp,%ebp
0804950e: push�� %edi
0804950f: push�� %esi
08049510: sub��� $0x20,%esp
08049513: cmpl�� $0x10,0x8(%ebp)
08049517: jle��� 0x08049525
08049519: movl�� $0x1,0xffffffe4(%ebp)
08049520: jmp��� 0x08049945

# Possible reference to data in bss
08049525: mov��� 0x80bdcfc,%ecx
0804952b: mov��� 0x8(%ebp),%eax
0804952e: mov��� %eax,%edx
08049530: shr��� $0x5,%edx
08049533: mov��� 0x8(%ebp),%eax
08049536: and��� $0x1f,%eax
08049539: bts��� %eax,(%ecx,%edx,4)
0804953d: movw�� $0x2,0xffffffee(%ebp)
08049543: movw�� $0x0,0xffffffea(%ebp)
08049549: movl�� $0x0,0xfffffff0(%ebp)
08049550: movl�� $0x0,0xfffffff4(%ebp)

# Possible reference to data in bss
08049557: cmpl�� $0x0,0x80bc8c8
0804955e: je���� 0x080495a7

# Possible reference to data in bss
08049560: mov��� 0x80bc8c8,%eax
08049565: mov��� %eax,0xfffffff4(%ebp)

# Possible reference to data in bss
08049568: mov��� 0x80bdd00,%eax
0804956d: mov��� %eax,0xffffffdc(%ebp)
08049570: movw�� $0x1,0xffffffea(%ebp)

# Possible reference to data ''
08049576: cmpw�� $0x0,0x80bb7a8
0804957e: je���� 0x0804958c

# Possible reference to data in bss
08049580: movl�� $0x0,0x80bc8c8
0804958a: jmp��� 0x080495a7

# Possible reference to data in bss
0804958c: mov��� 0x80bdcfc,%edx
08049592: mov��� $0x0,%eax
08049597: btr��� %eax,(%edx)
0804959a: sub��� $0xc,%esp
0804959d: push�� $0x0
0804959f: call�� 0x08055cc0 <__libc_close>
080495a4: add��� $0x10,%esp

# Possible reference to data in bss
080495a7: cmpl�� $0x0,0x80bc8f8
080495ae: je���� 0x080495c1
080495b0: sub��� $0xc,%esp

# Possible reference to data in bss
080495b3: pushl� 0x80bc8f8
080495b9: call�� 0x08054570 <__sleep>
080495be: add��� $0x10,%esp
080495c1: call�� 0x0804aad0 <__errno_location>
080495c6: movl�� $0x0,(%eax)
080495cc: mov��� 0x8(%ebp),%eax
080495cf: mov��� %eax,%ecx
080495d1: and��� $0x1f,%ecx

# Possible reference to data in bss
080495d4: mov��� 0x80bdcfc,%edx
080495da: mov��� 0x8(%ebp),%eax
080495dd: shr��� $0x5,%eax
080495e0: bt� ���%ecx,(%edx,%eax,4)
080495e4: setb�� %al
080495e7: test�� %al,%al
080495e9: jne��� 0x080495f0
080495eb: jmp��� 0x08049930
080495f0: movw�� $0x2008,0xffffffec(%ebp)
080495f6: cmpw�� $0x0,0xffffffea(%ebp)
080495fb: je���� 0x08049608
080495fd: movw�� $0x0,0xffffffea(%ebp)
08049603: jmp��� 0x080497e3

# Possible reference to data in bss
08049608: mov��� 0x80bdc40,%eax

# Possible reference to data in bss
0804960d: mov��� 0x80bdcfc,%edx
08049613: mov��� %eax,%edi
08049615: mov��� %edx,%esi
08049617: cld���
08049618: mov��� $0x20,%eax
0804961d: mov��� %eax,%ecx
0804961f: repz movsl %ds:(%esi),%es:(%edi)

# Possible reference to data in bss
08049621: cmpl�� $0x0,0x80bc8d4
08049628: je���� 0x08049643
0804962a: sub��� $0x4,%esp
0804962d: push�� $0x8

# Possible reference to data in bss
0804962f: pushl� 0x80bc8d4

# Possible reference to data in bss
08049635: pushl� 0x80bc8d8
0804963b: call�� 0x080543d0 <memcpy>
08049640: add��� $0x10,%esp
08049643: sub��� $0xc,%esp

# Possible reference to data in bss
08049646: pushl� 0x80bc8d8
0804964c: push�� $0x0
0804964e: push�� $0x0

# Possible reference to data in bss
08049650: pushl� 0x80bdc40
08049656: push�� $0x10
08049658: call�� 0x08056450 <__select>
0804965d: add��� $0x20,%esp
08049660: mov��� %eax,0xffffffe0(%ebp)
08049663: cmpl�� $0x0,0xffffffe0(%ebp)
08049667: jns��� 0x0804968d
08049669: call�� 0x0804aad0 <__errno_location>
0804966e: cmpl�� $0x4,(%eax)
08049671: je���� 0x0804968d
08049673: sub��� $0xc,%esp
08049676: pushl� 0x8(%ebp)
08049679: call�� 0x08055cc0 <__libc_close>
0804967e: add��� $0x10,%esp
08049681: movl�� $0x1,0xffffffe4(%ebp)
08049688: jmp��� 0x08049945
0804968d: cmpl�� $0x0,0xffffffe0(%ebp)
08049691: jne��� 0x080496d9
08049693: mov��� $0x0,%eax

# Possible reference to data in bss
08049698: mov��� 0x80bdcfc,%edx
0804969e: bt���� %eax,(%edx)
080496a1: setb�� %al
080496a4: test�� %al,%al
080496a6: jne��� 0x080496ae
080496a8: lea��� 0xffffffee(%ebp),%eax
080496ab: decw�� (%eax)
080496ae: cmpw�� $0x0,0xffffffee(%ebp)
080496b3: jne��� 0x080496d9

# Possible reference to data in bss
080496b5: cmpw�� $0x1,0x80bc906
080496bd: jbe��� 0x080496cd
080496bf: sub��� $0xc,%esp
080496c2: pushl� 0x8(%ebp)
080496c5: call�� 0x08055cc0 <__libc_close>
080496ca: add��� $0x10,%esp
080496cd: movl�� $0x0,0xffffffe4(%ebp)
080496d4: jmp��� 0x08049945
080496d9: mov��� 0x8(%ebp),%eax
080496dc: mov��� %eax,%ecx
080496de: and��� $0x1f,%ecx

# Possible reference to data in bss
080496e1: mov��� 0x80bdc40,%edx
080496e7: mov��� 0x8(%ebp),%eax
080496ea: shr��� $0x5,%eax
080496ed: bt���� %ecx,(%edx,%eax,4)
080496f1: setb�� %al
080496f4: test�� %al,%al
080496f6: je���� 0x08049749
080496f8: sub��� $0x4,%esp
080496fb: push�� $0x2000

# Possible reference to data in bss
08049700: pushl� 0x80bdc44
08049706: pushl� 0x8(%ebp)
08049709: call�� 0x08055d10 <__libc_read>
0804970e: add��� $0x10,%esp
08049711: mov��� %eax,0xffffffe0(%ebp)
08049714: cmpl�� $0x0,0xffffffe0(%ebp)
08049718: jg���� 0x0804973b

# Possible reference to data in bss
0804971a: mov��� 0x80bdcfc,%ecx
08049720: mov��� 0x8(%ebp),%eax
08049723: mov��� %eax,%edx
08049725: shr��� $0x5,%edx
08049728: mov��� 0x8(%ebp),%eax
0804972b: and��� $0x1f,%eax
0804972e: btr��� %eax,(%ecx,%edx,4)
08049732: movl�� $0x0,0xfffffff4(%ebp)
08049739: jmp��� 0x08049749
0804973b: mov��� 0xffffffe0(%ebp),%edx
0804973e: mov��� %edx,0xfffffff0(%ebp)

# Possible reference to data in bss
08049741: mov��� 0x80bdc44,%eax
08049746: mov��� %eax,0xffffffd8(%ebp)
08049749: cmpl�� $0x0,0xfffffff4(%ebp)
0804974d: je���� 0x08049754
0804974f: jmp��� 0x080497e3
08049754: mov��� $0x0,%eax

# Possible reference to data in bss
08049759: mov��� 0x80bdc40,%edx
0804975f: bt���� %eax,(%edx)
08049762: setb�� %al
08049765: test�� %al,%al
08049767: je���� 0x080497e3
08049769: sub��� $0x4,%esp
0804976c: push�� $0x2000

# Possible reference to data in bss
08049771: pushl� 0x80bdd00
08049777: push�� $0x0
08049779: call�� 0x08055d10 <__libc_read>
0804977e: add��� $0x10,%esp
08049781: mov��� %eax,0xffffffe0(%ebp)
08049784: cmpl�� $0x0,0xffffffe0(%ebp)
08049788: jg���� 0x080497a7

# Possible reference to data in bss
0804978a: mov��� 0x80bdcfc,%edx
08049790: mov��� $0x0,%eax
08049795: btr��� %eax,(%edx)
08049798: sub��� $0xc,%esp
0804979b: push�� $0x0
0804979d: call�� 0x08055cc0 <__libc_close>
080497a2: add��� $0x10,%esp
080497a5: jmp��� 0x080497e3
080497a7: mov��� 0xffffffe0(%ebp),%edx
080497aa: mov��� %edx,0xfffffff4(%ebp)

# Possible reference to data in bss
080497ad: mov��� 0x80bdd00,%eax
080497b2: mov��� %eax,0xffffffdc(%ebp)

# Possible reference to data ''
080497b5: cmpw�� $0x0,0x80bb7a8
080497bd: jne��� 0x080497e3
080497bf: mov��� 0xffffffe0(%ebp),%edx

# Possible reference to data in bss
080497c2: mov��� %edx,0x80bc8c8

# Possible reference to data in bss
080497c8: mov��� 0x80bdcfc,%edx
080497ce: mov��� $0x0,%eax
080497d3: btr��� %eax,(%edx)
080497d6: sub��� $0xc,%esp
080497d9: push�� $0x0
080497db: call�� 0x08055cc0 <__libc_close>
080497e0: add��� $0x10,%esp
080497e3: cmpl�� $0x2008,0xfffffff4(%ebp)
080497ea: ja���� 0x080497f7
080497ec: cmpl�� $0x2008,0xfffffff0(%ebp)
080497f3: ja���� 0x080497f7
080497f5: jmp��� 0x08049805
080497f7: movl�� $0x0,0xfffffff0(%ebp)
080497fe: movl�� $0x0,0xfffffff4(%ebp)
08049805: cmpw�� $0x0,0xffffffec(%ebp)
0804980a: jne��� 0x08049818
0804980c: movl�� $0x1,0xffffffe4(%ebp)
08049813: jmp��� 0x08049945
08049818: cmpl�� $0x0,0xfffffff0(%ebp)
0804981c: je���� 0x0804986e
0804981e: sub��� $0x4,%esp
08049821: pushl� 0xfffffff0(%ebp)
08049824: pushl� 0xffffffd8(%ebp)
08049827: push�� $0x1
08049829: call�� 0x08055d70 <__libc_write>
0804982e: add��� $0x10,%esp
08049831: mov��� %eax,0xffffffe0(%ebp)
08049834: cmpl�� $0x0,0xffffffe0(%ebp)
08049838: jle��� 0x0804986e

# Possible reference to data in bss
0804983a: cmpw�� $0x0,0x80bc900
08049842: je���� 0x08049857
08049844: sub��� $0x4,%esp
08049847: pushl� 0xffffffe0(%ebp)
0804984a: pushl� 0xffffffd8(%ebp)
0804984d: push�� $0x1
0804984f: call�� 0x08049311
08049854: add��� $0x10,%esp
08049857: mov��� 0xffffffe0(%ebp),%eax
0804985a: add��� %eax,0xffffffd8(%ebp)
0804985d: lea��� 0xfffffff0(%ebp),%eax
08049860: mov��� 0xffffffe0(%ebp),%edx
08049863: sub��� %edx,(%eax)
08049865: mov��� 0xffffffe0(%ebp),%eax

# Possible reference to data in bss
08049868: add��� %eax,0x80bc8cc
0804986e: cmpl�� $0x0,0xfffffff4(%ebp)
08049872: je���� 0x080498ea

# Possible reference to data in bss
08049874: cmpl�� $0x0,0x80bc8f8
0804987b: je���� 0x08049893
0804987d: sub��� $0x8,%esp
08049880: pushl� 0xfffffff4(%ebp)
08049883: pushl� 0xffffffdc(%ebp)
08049886: call�� 0x0804834b
0804988b: add��� $0x10,%esp
0804988e: mov��� %eax,0xffffffe0(%ebp)
08049891: jmp��� 0x08049899
08049893: mov��� 0xfffffff4(%ebp),%edx
08049896: mov��� %edx,0xffffffe0(%ebp)
08049899: sub��� $0x4,%esp
0804989c: pushl� 0xffffffe0(%ebp)
0804989f: pushl� 0xffffffdc(%ebp)
080498a2: pushl� 0x8(%ebp)
080498a5: call�� 0x08055d70 <__libc_write>
080498aa: add��� $0x10,%esp
080498ad: mov��� %eax,0xffffffe0(%ebp)
080498b0: cmpl�� $0x0,0xffffffe0(%ebp)
080498b4: jle��� 0x080498ea

# Possible reference to data in bss
080498b6: cmpw�� $0x0,0x80bc900
080498be: je���� 0x080498d3
080498c0: sub��� $0x4,%esp
080498c3: pushl� 0xffffffe0(%ebp)
080498c6: pushl� 0xffffffdc(%ebp)
080498c9: push�� $0x0
080498cb: call�� 0x08049311
080498d0: add��� $0x10,%esp
080498d3: mov��� 0xffffffe0(%ebp),%eax
080498d6: add��� %eax,0xffffffdc(%ebp)
080498d9: lea��� 0xfffffff4(%ebp),%eax
080498dc: mov��� 0xffffffe0(%ebp),%edx
080498df: sub��� %edx,(%eax)
080498e1: mov��� 0xffffffe0(%ebp),%eax

# Possible reference to data in bss
080498e4: add��� %eax,0x80bc8d0

# Possible reference to data in bss
080498ea: cmpl�� $0x0,0x80bc8f8
080498f1: je���� 0x08049914
080498f3: sub��� $0xc,%esp

# Possible reference to data in bss
080498f6: pushl� 0x80bc8f8
080498fc: call�� 0x08054570 <__sleep>
08049901: add��� $0x10,%esp
08049904: call�� 0x0804aad0 <__errno_location>
08049909: movl�� $0x0,(%eax)
0804990f: jmp��� 0x080495cc
08049914: cmpl�� $0x0,0xfffffff4(%ebp)
08049918: jne��� 0x08049925
0804991a: cmpl�� $0x0,0xfffffff0(%ebp)
0804991e: jne��� 0x08049925
08049920: jmp��� 0x080495cc
08049925: lea��� 0xffffffec(%ebp),%eax
08049928: decw�� (%eax)
0804992b: jmp��� 0x080497e3
08049930: sub��� $0xc,%esp
08049933: pushl� 0x8(%ebp)
08049936: call�� 0x08055cc0 <__libc_close>
0804993b: add��� $0x10,%esp
0804993e: movl�� $0x0,0xffffffe4(%ebp)
08049945: mov��� 0xffffffe4(%ebp),%eax
08049948: lea��� 0xfffffff8(%ebp),%esp
0804994b: pop��� %esi
0804994c: pop��� %edi
0804994d: pop��� %ebp
0804994e: ret���
0804994f: push�� %ebp
08049950: mov��� %esp,%ebp
08049952: sub��� $0x38,%esp
08049955: and��� $0xfffffff0,%esp
08049958: mov��� $0x0,%eax
0804995d: sub��� %eax,%esp
0804995f: movl�� $0x0,0xfffffff8(%ebp)
08049966: movl�� $0x0,0xfffffff4(%ebp)
0804996d: movl�� $0x0,0xfffffff0(%ebp)
08049974: movl�� $0x0,0xffffffec(%ebp)
0804997b: movw�� $0x0,0xffffffea(%ebp)
08049981: movw�� $0x0,0xffffffe8(%ebp)
08049987: movw�� $0x0,0xffffffe6(%ebp)
0804998d: movw�� $0x0,0xffffffe4(%ebp)
08049993: movw�� $0x0,0xffffffe2(%ebp)
08049999: movl�� $0x0,0xffffffdc(%ebp)
080499a0: sub��� $0xc,%esp
080499a3: push�� $0x10
080499a5: call�� 0x08048303
080499aa: add��� $0x10,%esp

# Possible reference to data in bss
080499ad: mov��� %eax,0x80bc8dc
080499b2: sub��� $0xc,%esp
080499b5: push�� $0x10
080499b7: call�� 0x08048303
080499bc: add��� $0x10,%esp

# Possible reference to data in bss
080499bf: mov��� %eax,0x80bc8e0
080499c4: sub��� $0xc,%esp
080499c7: push�� $0x2000
080499cc: call�� 0x08048303
080499d1: add��� $0x10,%esp

# Possible reference to data in bss
080499d4: mov��� %eax,0x80bdd00
080499d9: sub��� $0xc,%esp
080499dc: push�� $0x2000
080499e1: call�� 0x08048303
080499e6: add��� $0x10,%esp

# Possible reference to data in bss
080499e9: mov��� %eax,0x80bdc44
080499ee: sub��� $0xc,%esp
080499f1: push�� $0x80
080499f6: call�� 0x08048303
080499fb: add��� $0x10,%esp

# Possible reference to data in bss
080499fe: mov��� %eax,0x80bdcfc
08049a03: sub��� $0xc,%esp
08049a06: push�� $0x80
08049a0b: call�� 0x08048303
08049a10: add��� $0x10,%esp

# Possible reference to data in bss
08049a13: mov��� %eax,0x80bdc40
08049a18: sub��� $0xc,%esp
08049a1b: push�� $0x4a
08049a1d: call�� 0x08048303
08049a22: add��� $0x10,%esp

# Possible reference to data in bss
08049a25: mov��� %eax,0x80bc8ec
08049a2a: call�� 0x0804aad0 <__errno_location>
08049a2f: movl�� $0x0,(%eax)

# Possible reference to data ' '
08049a35: movl�� $0x4,0x80bb7a4
08049a3f: call�� 0x08056c00 <__h_errno_location>
08049a44: movl�� $0x0,(%eax)
08049a4a: sub��� $0x8,%esp
08049a4d: push�� $0x804823b
08049a52: push�� $0x2
08049a54: call�� 0x0804abc0 <__bsd_signal>
08049a59: add��� $0x10,%esp
08049a5c: sub��� $0x8,%esp
08049a5f: push�� $0x804823b
08049a64: push�� $0x3
08049a66: call�� 0x0804abc0 <__bsd_signal>
08049a6b: add��� $0x10,%esp
08049a6e: sub��� $0x8,%esp
08049a71: push�� $0x804823b
08049a76: push�� $0xf
08049a78: call�� 0x0804abc0 <__bsd_signal>
08049a7d: add��� $0x10,%esp
08049a80: sub��� $0x8,%esp
08049a83: push�� $0x1
08049a85: push�� $0x17
08049a87: call�� 0x0804abc0 <__bsd_signal>
08049a8c: add��� $0x10,%esp
08049a8f: sub��� $0x8,%esp
08049a92: push�� $0x1
08049a94: push�� $0xd
08049a96: call�� 0x0804abc0 <__bsd_signal>
08049a9b: add��� $0x10,%esp
08049a9e: cmpl�� $0x1,0x8(%ebp)
08049aa2: jne��� 0x08049c26
08049aa8: mov��� 0xc(%ebp),%eax
08049aab: mov��� (%eax),%eax
08049aad: mov��� %eax,0xffffffd4(%ebp)
08049ab0: sub��� $0xc,%esp
08049ab3: push�� $0x200
08049ab8: call�� 0x08048303
08049abd: add��� $0x10,%esp
08049ac0: mov��� %eax,0xc(%ebp)
08049ac3: mov��� 0xc(%ebp),%eax
08049ac6: mov��� 0xffffffd4(%ebp),%edx
08049ac9: mov��� %edx,(%eax)
08049acb: sub��� $0xc,%esp
08049ace: push�� $0x2000
08049ad3: call�� 0x08048303
08049ad8: add�� �$0x10,%esp
08049adb: mov��� %eax,0xffffffd4(%ebp)
08049ade: mov��� 0xc(%ebp),%eax
08049ae1: add��� $0x4,%eax
08049ae4: mov��� 0xffffffd4(%ebp),%ecx
08049ae7: mov��� %ecx,(%eax)
08049ae9: sub��� $0x8,%esp

# Possible reference to rodata 'Cmd: '
08049aec: push�� $0x80a44f5

# Possible reference to data '<
'
08049af1: pushl� 0x80bbd24
08049af7: call�� 0x0804bf70
08049afc: add��� $0x10,%esp
08049aff: sub��� $0xc,%esp

# Possible reference to data '<
'
08049b02: pushl� 0x80bbd24
08049b08: call�� 0x0804bfb0 <_IO_fflush>
08049b0d: add��� $0x10,%esp
08049b10: sub��� $0x4,%esp
08049b13: push�� $0x2000
08049b18: pushl� 0xffffffd4(%ebp)
08049b1b: push�� $0x0
08049b1d: call�� 0x08055d10 <__libc_read>
08049b22: add��� $0x10,%esp

# Possible reference to data in bss
08049b25: mov��� %eax,0x80bc8c8

# Possible reference to data in bss
08049b2a: cmpl�� $0x0,0x80bc8c8
08049b31: jne��� 0x08049b38
08049b33: call�� 0x08048204
08049b38: sub��� $0x8,%esp

# Possible reference to data in bss
08049b3b: pushl� 0x80bc8c8
08049b41: pushl� 0xffffffd4(%ebp)
08049b44: call�� 0x0804834b
08049b49: add��� $0x10,%esp
08049b4c: mov��� %eax,0xffffffd8(%ebp)
08049b4f: cmpl�� $0x0,0xffffffd8(%ebp)
08049b53: je���� 0x08049b5e
08049b55: mov��� 0xffffffd8(%ebp),%eax

# Possible reference to data in bss
08049b58: sub��� %eax,0x80bc8c8

# Possible reference to data in bss
08049b5e: cmpl�� $0x0,0x80bc8c8
08049b65: je���� 0x08049b85
08049b67: sub��� $0x4,%esp

# Possible reference to data in bss
08049b6a: pushl� 0x80bc8c8
08049b70: mov��� 0xffffffd4(%ebp),%eax
08049b73: add��� 0xffffffd8(%ebp),%eax
08049b76: push�� %eax

# Possible reference to data in bss
08049b77: pushl� 0x80bdd00
08049b7d: call�� 0x080543d0 <memcpy>
08049b82: add��� $0x10,%esp
08049b85: mov��� 0xc(%ebp),%eax
08049b88: add��� $0x4,%eax
08049b8b: sub��� $0x8,%esp
08049b8e: push�� $0xa
08049b90: pushl� (%eax)
08049b92: call�� 0x08053b70 <strchr>
08049b97: add��� $0x10,%esp
08049b9a: mov��� %eax,0xffffffd4(%ebp)
08049b9d: cmpl�� $0x0,0xffffffd4(%ebp)
08049ba1: je���� 0x08049ba9
08049ba3: mov��� 0xffffffd4(%ebp),%edx
08049ba6: movb�� $0x0,(%edx)
08049ba9: mov��� 0xc(%ebp),%eax
08049bac: add��� $0x4,%eax
08049baf: sub��� $0x8,%esp
08049bb2: push�� $0xd
08049bb4: pushl� (%eax)
08049bb6: call�� 0x08053b70 <strchr>
08049bbb: add��� $0x10,%esp
08049bbe: mov��� %eax,0xffffffd4(%ebp)
08049bc1: cmpl�� $0x0,0xffffffd4(%ebp)
08049bc5: je���� 0x08049bcd
08049bc7: mov��� 0xffffffd4(%ebp),%ecx
08049bca: movb�� $0x0,(%ecx)
08049bcd: mov��� 0xc(%ebp),%eax
08049bd0: add��� $0x4,%eax
08049bd3: mov��� (%eax),%eax
08049bd5: mov��� %eax,0xffffffd4(%ebp)
08049bd8: incl�� 0xffffffd4(%ebp)
08049bdb: movl�� $0x2,0xffffffd8(%ebp)
08049be2: mov��� 0xffffffd4(%ebp),%eax
08049be5: cmpb�� $0x0,(%eax)
08049be8: jne��� 0x08049bec
08049bea: jmp��� 0x08049c20
08049bec: mov��� 0xffffffd4(%ebp),%edx
08049bef: cmpb�� $0x20,(%edx)
08049bf2: jne��� 0x08049bfc
08049bf4: mov��� 0xffffffd4(%ebp),%ecx
08049bf7: movb�� $0x0,(%ecx)
08049bfa: jmp��� 0x08049c1b
08049bfc: mov��� 0xffffffd4(%ebp),%eax
08049bff: cmpb�� $0x0,0xffffffff(%eax)
08049c03: jne��� 0x08049c1b
08049c05: mov��� 0xffffffd8(%ebp),%eax
08049c08: lea��� 0x0(,%eax,4),%edx
08049c0f: mov��� 0xc(%ebp),%eax
08049c12: mov��� 0xffffffd4(%ebp),%ecx
08049c15: mov��� %ecx,(%eax,%edx,1)
08049c18: incl�� 0xffffffd8(%ebp)
08049c1b: incl�� 0xffffffd4(%ebp)
08049c1e: jmp��� 0x08049be2
08049c20: mov��� 0xffffffd8(%ebp),%eax
08049c23: mov��� %eax,0x8(%ebp)
08049c26: nop���
08049c27: sub��� $0x4,%esp

# Possible reference to rodata 'ae:g:G:hi:lno:p:rs:tuvw:z'
08049c2a: push�� $0x80a44fb
08049c2f: pushl� 0xc(%ebp)
08049c32: pushl� 0x8(%ebp)
08049c35: call�� 0x08055b70 <getopt>
08049c3a: add��� $0x10,%esp
08049c3d: mov��� %eax,0xffffffd8(%ebp)
08049c40: mov��� 0xffffffd8(%ebp),%eax
08049c43: cmp��� $0xffffffff,%eax
08049c46: jne��� 0x08049c4d
08049c48: jmp��� 0x08049e9f
08049c4d: mov��� 0xffffffd8(%ebp),%edx
08049c50: sub��� $0x47,%edx
08049c53: mov��� %edx,0xffffffd0(%ebp)
08049c56: cmpl�� $0x33,0xffffffd0(%ebp)
08049c5a: ja���� 0x08049e8a
08049c60: mov��� 0xffffffd0(%ebp),%ecx

# Possible reference to rodata ' /proc/sys/kernel/osrelease'
08049c63: mov��� 0x80a4518(,%ecx,4),%eax
08049c6a: jmp��� *%eax
08049c6c: call�� 0x08048204

# Possible reference to data in bss
08049c71: incw�� 0x80bc8f4
08049c78: jmp��� 0x08049c27

# Possible reference to data in bss
08049c7a: mov��� 0x80bdda4,%eax

# Possible reference to data in bss
08049c7f: mov��� %eax,0x80bc910
08049c84: jmp��� 0x08049c27
08049c86: sub��� $0xc,%esp

# Possible reference to data in bss
08049c89: pushl� 0x80bdda4
08049c8f: call�� 0x0804aed0
08049c94: add��� $0x10,%esp
08049c97: mov� ��%eax,0xffffffd8(%ebp)
08049c9a: cmpl�� $0x0,0xffffffd8(%ebp)
08049c9e: je���� 0x08049cb8
08049ca0: mov��� 0xffffffd8(%ebp),%eax
08049ca3: and��� $0x1c,%eax
08049ca6: cmp��� %eax,0xffffffd8(%ebp)
08049ca9: jne��� 0x08049cb8
08049cab: mov��� 0xffffffd8(%ebp),%eax

# Possible reference to data '
08049cae: mov��� %eax,0x80bb7a4
08049cb3: jmp��� 0x08049c27
08049cb8: call�� 0x08048204
08049cbd: jmp��� 0x08049c27

# Possible reference to data in bss
08049cc2: cmpl�� $0x8,0x80bc8c4
08049cc9: jle��� 0x08049cd0
08049ccb: call�� 0x08048204

# Possible reference to data in bss
08049cd0: cmpl�� $0x0,0x80bc8e4
08049cd7: jne��� 0x08049ceb
08049cd9: sub��� $0xc,%esp
08049cdc: push�� $0x28
08049cde: call�� 0x08048303
08049ce3: add��� $0x10,%esp

# Possible reference to data in bss
08049ce6: mov��� %eax,0x80bc8e4
08049ceb: sub��� $0x8,%esp

# Possible reference to data in bss
08049cee: mov��� 0x80bc8fe,%ax
08049cf4: and��� $0xffff,%eax
08049cf9: push�� %eax

# Possible reference to data in bss
08049cfa: pushl� 0x80bdda4
08049d00: call�� 0x080483fd
08049d05: add��� $0x10,%esp
08049d08: mov��� %eax,0xfffffffc(%ebp)
08049d0b: cmpl�� $0x0,0xfffffffc(%ebp)
08049d0f: je���� 0x08049d29

# Possible reference to data in bss
08049d11: mov��� 0x80bc8c4,%eax
08049d16: lea��� 0x0(,%eax,4),%ecx

# Possible reference to data in bss
08049d1d: mov��� 0x80bc8e4,%edx
08049d23: mov��� 0xfffffffc(%ebp),%eax
08049d26: mov��� %eax,(%edx,%ecx,1)

# Possible reference to data in bss
08049d29: incl�� 0x80bc8c4
08049d2f: jmp��� 0x08049c27
08049d34: call�� 0x0804aad0 <__errno_location>
08049d39: movl�� $0x0,(%eax)
08049d3f: call�� 0x08048204
08049d44: sub��� $0xc,%esp

# Possible reference to data in bss
08049d47: pushl� 0x80bdda4
08049d4d: call�� 0x0804aed0
08049d52: add��� $0x10,%esp
08049d55: and��� $0xffff,%eax

# Possible reference to data in bss
08049d5a: mov��� %eax,0x80bc8f8

# Possible reference to data in bss
08049d5f: cmpl�� $0x0,0x80bc8f8
08049d66: jne��� 0x08049c27
08049d6c: call�� 0x08048204
08049d71: jmp��� 0x08049c27

# Possible reference to data in bss
08049d76: incw�� 0x80bc8fc
08049d7d: jmp��� 0x08049c27

# Possible reference to data in bss
08049d82: incw�� 0x80bc8fe
08049d89: jmp��� 0x08049c27

# Possible reference to data in bss
08049d8e: mov��� 0x80bdda4,%eax

# Possible reference to data in bss
08049d93: mov��� %eax,0x80bc8f0

# Possible reference to data in bss
08049d98: incw�� 0x80bc900
08049d9f: jmp��� 0x08049c27
08049da4: sub��� $0x8,%esp
08049da7: push�� $0x0

# Possible reference to data in bss
08049da9: pushl� 0x80bdda4
08049daf: call�� 0x080486b8
08049db4: add��� $0x10,%esp
08049db7: mov��� %ax,0xffffffea(%ebp)
08049dbb: cmpw�� $0x0,0xffffffea(%ebp)
08049dc0: jne��� 0x08049c27
08049dc6: call�� 0x08048204
08049dcb: jmp��� 0x08049c27

# Possible reference to data in bss
08049dd0: incw�� 0x80bc902
08049dd7: jmp��� 0x08049c27
08049ddc: sub��� $0x8,%esp

# Possible reference to data in bss
08049ddf: mov��� 0x80bc8fe,%ax
08049de5: and��� $0xffff,%eax
08049dea: push�� %eax

# Possible reference to data in bss
08049deb: pushl� 0x80bdda4
08049df1: call�� 0x080483fd
08049df6: add��� $0x10,%esp
08049df9: mov��� %eax,0xfffffff4(%ebp)
08049dfc: mov��� 0xfffffff4(%ebp),%eax
08049dff: add��� $0x1c0,%eax
08049e04: mov��� %eax,0xfffffff0(%ebp)
08049e07: jmp��� 0x08049c27

# Possible reference to data in bss
08049e0c: incw�� 0x80bc904
08049e13: jmp��� 0x08049c27

# Possible reference to data in bss
08049e18: incw�� 0x80bc906
08049e1f: jmp��� 0x08049c27
08049e24: sub��� $0xc,%esp

# Possible reference to data in bss
08049e27: pushl� 0x80bdda4
08049e2d: call�� 0x0804aed0
08049e32: add��� $0x10,%esp

# Possible reference to data in bss
08049e35: mov��� %eax,0x80bc908

# Possible reference to data in bss
08049e3a: cmpl�� $0x0,0x80bc908
08049e41: jne��� 0x08049e48
08049e43: call�� 0x08048204
08049e48: sub��� $0xc,%esp
08049e4b: push�� $0x8
08049e4d: call�� 0x08048303
08049e52: add��� $0x10,%esp

# Possible reference to data in bss
08049e55: mov��� %eax,0x80bc8d4
08049e5a: sub��� $0xc,%esp
08049e5d: push�� $0x8
08049e5f: call�� 0x08048303
08049e64: add�� �$0x10,%esp

# Possible reference to data in bss
08049e67: mov��� %eax,0x80bc8d8

# Possible reference to data in bss
08049e6c: mov��� 0x80bc8d4,%edx

# Possible reference to data in bss
08049e72: mov��� 0x80bc908,%eax
08049e77: mov��� %eax,(%edx)
08049e79: jmp��� 0x08049c27

# Possible reference to data in bss
08049e7e: incw�� 0x80bc90c
08049e85: jmp��� 0x08049c27
08049e8a: call�� 0x0804aad0 <__errno_location>
08049e8f: movl�� $0x0,(%eax)
08049e95: call�� 0x08048204
08049e9a: jmp��� 0x08049c27

# Possible reference to data in bss
08049e9f: mov��� 0x80bdcfc,%edx
08049ea5: mov��� $0x0,%eax
08049eaa: bts��� %eax,(%edx)

# Possible reference to data in bss
08049ead: cmpw�� $0x0,0x80bc902
08049eb5: je���� 0x08049ee0
08049eb7: sub��� $0xc,%esp
08049eba: push�� $0x0
08049ebc: call�� 0x08054520 <time>
08049ec1: add��� $0x4,%esp
08049ec4: push�� %eax
08049ec5: call�� 0x0804b150 <__srandom>
08049eca: add��� $0x10,%esp
08049ecd: sub��� $0xc,%esp
08049ed0: push�� $0x10000
08049ed5: call�� 0x08048303
08049eda: add��� $0x10,%esp
08049edd: mov��� %eax,0xffffffdc(%ebp)

# Possible reference to data in bss
08049ee0: cmpl�� $0x0,0x80bc910
08049ee7: je���� 0x08049f09
08049ee9: sub��� $0xc,%esp
08049eec: push�� $0x0
08049eee: call�� 0x08055cc0 <__libc_close>
08049ef3: add��� $0x10,%esp

# Possible reference to data in bss
08049ef6: movw�� $0x0,0x80bc900

# Possible reference to data in bss
08049eff: movl�� $0x0,0x80bc8c0

# Possible reference to data in bss
08049f09: cmpw�� $0x0,0x80bc900
08049f11: je���� 0x08049f53
08049f13: sub��� $0x4,%esp
08049f16: push�� $0x1b4
08049f1b: push�� $0x241

# Possible reference to data in bss
08049f20: pushl� 0x80bc8f0
08049f26: call�� 0x08055c60 <__libc_open>
08049f2b: add��� $0x10,%esp

# Possible reference to data in bss
08049f2e: mov��� %eax,0x80bc8c0

# Possible reference to data in bss
08049f33: cmpl�� $0x0,0x80bc8c0
08049f3a: jg���� 0x08049f41
08049f3c: call�� 0x08048204
08049f41: sub��� $0xc,%esp
08049f44: push�� $0x64
08049f46: call�� 0x08048303
08049f4b: add��� $0x10,%esp

# Possible reference to data in bss
08049f4e: mov��� %eax,0x80bc8f0

# Possible reference to data ''
08049f53: mov��� 0x80bbdac,%eax
08049f58: lea��� 0x0(,%eax,4),%edx
08049f5f: mov��� 0xc(%ebp),%eax
08049f62: cmpl�� $0x0,(%eax,%edx,1)
08049f66: je���� 0x08049f94
08049f68: sub��� $0x8,%esp

# Possible reference to data in bss
08049f6b: mov��� 0x80bc8fe,%ax
08049f71: and��� $0xffff,%eax
08049f76: push�� %eax

# Possible reference to data ''
08049f77: mov��� 0x80bbdac,%eax
08049f7c: lea��� 0x0(,%eax,4),%edx
08049f83: mov ���0xc(%ebp),%eax
08049f86: pushl� (%eax,%edx,1)
08049f89: call�� 0x080483fd
08049f8e: add��� $0x10,%esp
08049f91: mov��� %eax,0xfffffff8(%ebp)
08049f94: cmpl�� $0x0,0xfffffff8(%ebp)
08049f98: je���� 0x08049fae
08049f9a: cmpl�� $0xfffffe40,0xfffffff8(%ebp)
08049fa1: je���� 0x08049fae
08049fa3: mov��� 0xfffffff8(%ebp),%eax
08049fa6: add��� $0x1c0,%eax
08049fab: mov��� %eax,0xffffffec(%ebp)
08049fae: cmpl�� $0x0,0xffffffec(%ebp)
08049fb2: je���� 0x08049fba

# Possible reference to data ''
08049fb4: incl�� 0x80bbdac
08049fba: call�� 0x0804aad0 <__errno_location>
08049fbf: movl�� $0x0,(%eax)
08049fc5: call�� 0x08056c00 <__h_errno_location>
08049fca: movl�� $0x0,(%eax)

# Possible reference to data in bss
08049fd0: cmpw�� $0x0,0x80bc8fc
08049fd8: je���� 0x0804a0a0
08049fde: movw�� $0x0,0xffffffe2(%ebp)

# Possible reference to data ''
08049fe4: mov��� 0x80bbdac,%eax
08049fe9: lea��� 0x0(,%eax,4),%edx
08049ff0: mov��� 0xc(%ebp),%eax
08049ff3: cmpl�� $0x0,(%eax,%edx,1)
08049ff7: je���� 0x0804a028
08049ff9: sub��� $0x8,%esp
08049ffc: push�� $0x0

# Possible reference to data ''
08049ffe: mov��� 0x80bbdac,%eax
0804a003: lea��� 0x0(,%eax,4),%edx
0804a00a: mov��� 0xc(%ebp),%eax
0804a00d: pushl� (%eax,%edx,1)
0804a010: call�� 0x080486b8
0804a015: add��� $0x10,%esp
0804a018: mov��� %ax,0xffffffe2(%ebp)
0804a01c: cmpw�� $0x0,0xffffffe2(%ebp)
0804a021: jne��� 0x0804a028
0804a023: call�� 0x08048204
0804a028: mov��� 0xffffffea(%ebp),%ax
0804a02c: and��� $0xffff,%eax
0804a031: push�� %eax
0804a032: pushl� 0xfffffff0(%ebp)
0804a035: mov��� 0xffffffe2(%ebp),%ax
0804a039: and��� $0xffff,%eax
0804a03e: push�� %eax
0804a03f: pushl� 0xffffffec(%ebp)
0804a042: call�� 0x08048d9d
0804a047: add��� $0x10,%esp

# Possible reference to data '(UNKNOWN)'
0804a04a: mov��� %eax,0x80bb78c

# Possible reference to data '(UNKNOWN)'
0804a04f: cmpl�� $0x0,0x80bb78c
0804a056: jle��� 0x0804a09b

# Possible reference to data in bss
0804a058: cmpl�� $0x0,0x80bc910
0804a05f: je���� 0x0804a072
0804a061: sub��� $0xc,%esp

# Possible reference to data '(UNKNOWN)'
0804a064: pushl� 0x80bb78c
0804a06a: call�� 0x080489b3
0804a06f: add��� $0x10,%esp
0804a072: sub��� $0xc,%esp

# Possible reference to data '(UNKNOWN)'
0804a075: pushl� 0x80bb78c
0804a07b: call�� 0x0804950b
0804a080: add��� $0x10,%esp
0804a083: mov��� %eax,0xffffffd8(%ebp)

# Possible reference to data in bss
0804a086: cmpw�� $0x1,0x80bc906
0804a08e: jbe��� 0x0804a0a0
0804a090: sub��� $0xc,%esp
0804a093: pushl� 0xffffffd8(%ebp)
0804a096: call�� 0x0804aef0 <exit>
0804a09b: call�� 0x08048204
0804a0a0: cmpl�� $0x0,0xffffffec(%ebp)
0804a0a4: jne��� 0x0804a0ab
0804a0a6: call�� 0x08048204

# Possible reference to data ''
0804a0ab: mov��� 0x80bbdac,%eax
0804a0b0: lea��� 0x0(,%eax,4),%edx
0804a0b7: mov��� 0xc(%ebp),%eax
0804a0ba: cmpl�� $0x0,(%eax,%edx,1)
0804a0be: jne��� 0x0804a0c5
0804a0c0: call�� 0x08048204

# Possible reference to data ''
0804a0c5: mov��� 0x80bbdac,%eax
0804a0ca: shl��� $0x2,%eax
0804a0cd: add��� 0xc(%ebp),%eax
0804a0d0: add��� $0x4,%eax
0804a0d3: cmpl�� $0x0,(%eax)
0804a0d6: je���� 0x0804a0e1

# Possible reference to data ''
0804a0d8: movw�� $0x0,0x80bb7a8
0804a0e1: mov��� 0xffffffea(%ebp),%ax
0804a0e5: mov��� %ax,0xffffffe8(%ebp)

# Possible reference to data ''
0804a0e9: mov��� 0x80bbdac,%eax
0804a0ee: lea��� 0x0(,%eax,4),%edx
0804a0f5: mov��� 0xc(%ebp),%eax
0804a0f8: cmpl�� $0x0,(%eax,%edx,1)
0804a0fc: jne��� 0x0804a103
0804a0fe: jmp��� 0x0804a36e
0804a103: movw�� $0x0,0xffffffe6(%ebp)
0804a109: movw�� $0x0,0xffffffe4(%ebp)

# Possible reference to data ''
0804a10f: mov��� 0x80bbdac,%eax
0804a114: lea��� 0x0(,%eax,4),%edx
0804a11b: mov��� 0xc(%ebp),%eax
0804a11e: sub��� $0x8,%esp
0804a121: push�� $0x2d
0804a123: pushl� (%eax,%edx,1)
0804a126: call�� 0x08053b70 <strchr>
0804a12b: add��� $0x10,%esp
0804a12e: mov��� %eax,0xffffffd4(%ebp)
0804a131: cmpl�� $0x0,0xffffffd4(%ebp)
0804a135: je���� 0x0804a160
0804a137: mov��� 0xffffffd4(%ebp),%edx
0804a13a: movb�� $0x0,(%edx)
0804a13d: incl�� 0xffffffd4(%ebp)
0804a140: sub��� $0x8,%esp
0804a143: push�� $0x0
0804a145: pushl� 0xffffffd4(%ebp)
0804a148: call�� 0x080486b8
0804a14d: add��� $0x10,%esp
0804a150: mov��� %ax,0xffffffe4(%ebp)
0804a154: cmpw�� $0x0,0xffffffe4(%ebp)
0804a159: jne��� 0x0804a160
0804a15b: call�� 0x08048204
0804a160: sub��� $0x8,%esp
0804a163: push�� $0x0

# Possible reference to data ''
0804a165: mov��� 0x80bbdac,%eax
0804a16a: lea��� 0x0(,%eax,4),%edx
0804a171: mov��� 0xc(%ebp),%eax
0804a174: pushl� (%eax,%edx,1)
0804a177: call�� 0x080486b8
0804a17c: add��� $0x10,%esp
0804a17f: mov��� %ax,0xffffffe6(%ebp)
0804a183: cmpw�� $0x0,0xffffffe6(%ebp)
0804a188: jne��� 0x0804a18f
0804a18a: call�� 0x08048204
0804a18f: mov��� 0xffffffe4(%ebp),%eax
0804a192: cmp��� 0xffffffe6(%ebp),%ax
0804a196: jbe��� 0x0804a1e7

# Possible reference to data ''
0804a198: movw�� $0x0,0x80bb7a8
0804a1a1: mov��� 0xffffffe4(%ebp),%eax
0804a1a4: mov��� %ax,0xffffffe2(%ebp)

# Possible reference to data in bss
0804a1a8: cmpw�� $0x0,0x80bc902
0804a1b0: je���� 0x0804a1ef
0804a1b2: sub��� $0x4,%esp
0804a1b5: mov��� 0xffffffe4(%ebp),%eax
0804a1b8: and��� $0xffff,%eax
0804a1bd: push�� %eax
0804a1be: mov��� 0xffffffe6(%ebp),%ax
0804a1c2: and��� $0xffff,%eax
0804a1c7: push�� %eax
0804a1c8: pushl� 0xffffffdc(%ebp)
0804a1cb: call�� 0x08048951
0804a1d0: add��� $0x10,%esp
0804a1d3: sub��� $0xc,%esp
0804a1d6: pushl� 0xffffffdc(%ebp)
0804a1d9: call�� 0x080488ab
0804a1de: add��� $0x10,%esp
0804a1e1: mov��� %ax,0xffffffe2(%ebp)
0804a1e5: jmp��� 0x0804a1ef
0804a1e7: mov��� 0xffffffe6(%ebp),%ax
0804a1eb: mov��� %ax,0xffffffe2(%ebp)
0804a1ef: nop���
0804a1f0: mov��� 0xffffffe6(%ebp),%ax
0804a1f4: cmp��� 0xffffffe2(%ebp),%ax
0804a1f8: jbe��� 0x0804a1ff
0804a1fa: jmp��� 0x0804a363
0804a1ff: cmpw�� $0x0,0xffffffea(%ebp)
0804a204: jne��� 0x0804a230

# Possible reference to data in bss
0804a206: cmpw�� $0x0,0x80bc902
0804a20e: je���� 0x0804a230
0804a210: call�� 0x0804b260 <__random>
0804a215: mov��� $0xffffffff,%edx
0804a21a: and��� %edx,%eax
0804a21c: mov��� %ax,0xffffffe8(%ebp)
0804a220: cmpw�� $0x1fff,0xffffffe8(%ebp)
0804a226: ja���� 0x0804a230
0804a228: lea��� 0xffffffe8(%ebp),%eax
0804a22b: addw�� $0x2000,(%eax)
0804a230: sub��� $0x8,%esp
0804a233: mov��� 0xffffffe2(%ebp),%ax
0804a237: and��� $0xffff,%eax
0804a23c: push�� %eax
0804a23d: push�� $0x0
0804a23f: call�� 0x080486b8
0804a244: add��� $0x10,%esp
0804a247: mov��� %ax,0xffffffe2(%ebp)
0804a24b: mov��� 0xffffffe8(%ebp),%eax
0804a24e: and��� $0xffff,%eax
0804a253: push�� %eax
0804a254: pushl� 0xfffffff0(%ebp)
0804a257: mov��� 0xffffffe2(%ebp),%ax
0804a25b: and��� $0xffff,%eax
0804a260: push�� %eax
0804a261: pushl� 0xffffffec(%ebp)
0804a264: call�� 0x08048a3b
0804a269: add��� $0x10,%esp

# Possible reference to data '(UNKNOWN)'
0804a26c: mov��� %eax,0x80bb78c

# Possible reference to data '(UNKNOWN)'
0804a271: cmpl�� $0x0,0x80bb78c
0804a278: jle��� 0x0804a2a7

# Possible reference to data in bss
0804a27a: cmpw�� $0x0,0x80bc90c
0804a282: je���� 0x0804a2a7

# Possible reference to data in bss
0804a284: cmpw�� $0x0,0x80bc904
0804a28c: je���� 0x0804a2a7
0804a28e: sub��� $0x8,%esp
0804a291: pushl� 0xffffffec(%ebp)

# Possible reference to data '(UNKNOWN)'
0804a294: pushl� 0x80bb78c
0804a29a: call�� 0x08049235
0804a29f: add��� $0x10,%esp

# Possible reference to data '(UNKNOWN)'
0804a2a2: mov��� %eax,0x80bb78c

# Possible reference to data '(UNKNOWN)'
0804a2a7: cmpl�� $0x0,0x80bb78c
0804a2ae: jle��� 0x0804a2f1
0804a2b0: movl�� $0x0,0xffffffd8(%ebp)

# Possible reference to data in bss
0804a2b7: cmpl�� $0x0,0x80bc910
0804a2be: je���� 0x0804a2d1
0804a2c0: sub��� $0xc,%esp

# Possible reference to data '(UNKNOWN)'
0804a2c3: pushl� 0x80bb78c
0804a2c9: call�� 0x080489b3
0804a2ce: add��� $0x10,%esp

# Possible reference to data in bss
0804a2d1: cmpw�� $0x0,0x80bc90c
0804a2d9: jne��� 0x0804a30c
0804a2db: sub��� $0xc,%esp

# Possible reference to data '(UNKNOWN)'
0804a2de: pushl� 0x80bb78c
0804a2e4: call�� 0x0804950b
0804a2e9: add��� $0x10,%esp
0804a2ec: mov��� %eax,0xffffffd8(%ebp)
0804a2ef: jmp��� 0x0804a30c
0804a2f1: movl�� $0x1,0xffffffd8(%ebp)

# Possible reference to data ''
0804a2f8: cmpw�� $0x0,0x80bb7a8
0804a300: jne��� 0x0804a30c

# Possible reference to data in bss
0804a302: cmpw�� $0x1,0x80bc906
0804a30a: ja���� 0x0804a30c
0804a30c: sub��� $0xc,%esp

# Possible reference to data '(UNKNOWN)'
0804a30f: pushl� 0x80bb78c
0804a315: call�� 0x08055cc0 <__libc_close>
0804a31a: add��� $0x10,%esp

# Possible reference to data in bss
0804a31d: cmpl�� $0x0,0x80bc8f8
0804a324: je���� 0x0804a337
0804a326: sub��� $0xc,%esp

# Possible reference to data in bss
0804a329: pushl� 0x80bc8f8
0804a32f: call�� 0x08054570 <__sleep>
0804a334: add��� $0x10,%esp

# Possible reference to data in bss
0804a337: cmpw�� $0x0,0x80bc902
0804a33f: je���� 0x0804a358
0804a341: sub��� $0xc,%esp
0804a344: pushl� 0xffffffdc(%ebp)
0804a347: call�� 0x080488ab
0804a34c: add��� $0x10,%esp
0804a34f: mov��� %ax,0xffffffe2(%ebp)
0804a353: jmp��� 0x0804a1f0
0804a358: lea��� 0xffffffe2(%ebp),%eax
0804a35b: decw�� (%eax)
0804a35e: jmp��� 0x0804a1f0

# Possible reference to data ''
0804a363: incl�� 0x80bbdac
0804a369: jmp��� 0x0804a0e9
0804a36e: call�� 0x0804aad0 <__errno_location>
0804a373: movl�� $0x0,(%eax)

# Possible reference to data in bss
0804a379: cmpw�� $0x1,0x80bc906
0804a381: jbe��� 0x0804a398

# Possible reference to data ''
0804a383: cmpw�� $0x0,0x80bb7a8
0804a38b: je���� 0x0804a398
0804a38d: sub��� $0xc,%esp
0804a390: pushl� 0xffffffd8(%ebp)
0804a393: call�� 0x0804aef0 <exit>
0804a398: sub��� $0xc,%esp
0804a39b: push�� $0x0
0804a39d: call�� 0x0804aef0 <exit>
0804a3a2: nop���
0804a3a3: nop���
0804a3a4: nop���
0804a3a5: nop ���
0804a3a6: nop���
0804a3a7: nop���
0804a3a8: nop���
0804a3a9: nop���
0804a3aa: nop���
0804a3ab: nop���
0804a3ac: nop���
0804a3ad: nop���
0804a3ae: nop���
0804a3af: nop���
0804aed0: push�� %ebp
0804aed1: mov��� %esp,%ebp
0804aed3: push�� $0x0
0804aed5: push�� $0xa
0804aed7: push�� $0x0
0804aed9: mov��� 0x8(%ebp),%eax
0804aedc: push�� %eax
0804aedd: call�� 0x0804b680 <__strtol_internal>
0804aee2: add��� $0x10,%esp
0804aee5: leave�
0804aee6: ret���
0804aee7: nop���
0804aee8: nop���
0804aee9: nop���
0804aeea: nop���
0804aeeb: nop���
0804aeec: nop���
0804aeed: nop���
0804aeee: nop���
0804aeef: nop���