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