#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef void *u_int8_t;
typedef int u_int32_t;
typedef int /*<<< orphan*/ u_char;

/* Variables and functions */
int /*<<< orphan*/ PUTLONG(int, int /*<<< orphan*/ *);
scalar_t__ isdigit(char const);
scalar_t__ isspace(char const);
int latlon2ul(char **, int *);
void *precsize_aton(char **);
int strlen(char const *);
int loc_aton(const char *ascii, u_char *binary) {
  const char *cp, *maxcp;
  u_char *bcp;
  u_int32_t latit = 0, longit = 0, alt = 0;
  u_int32_t lltemp1 = 0, lltemp2 = 0;
  int altmeters = 0, altfrac = 0, altsign = 1;
  u_int8_t hp = 0x16;
  u_int8_t vp = 0x13;
  u_int8_t siz = 0x12;
  int which1 = 0, which2 = 0;
  cp = ascii;
  maxcp = cp + strlen(ascii);
  lltemp1 = latlon2ul((char **)&cp, &which1);
  lltemp2 = latlon2ul((char **)&cp, &which2);
  switch (which1 + which2) {
  case 3:
    if ((which1 == 1) && (which2 == 2)) {
      latit = lltemp1;
      longit = lltemp2;
    } else if ((which1 == 2) && (which2 == 1)) {
      longit = lltemp1;
      latit = lltemp2;
    } else {
      return (0);
    }
    break;
  default:
    return (0);
  }
  if (*cp == '-') {
    altsign = -1;
    cp++;
  }
  if (*cp == '+')
    cp++;
  while (isdigit(*cp))
    altmeters = altmeters * 10 + (*cp++ - '0');
  if (*cp == '.') {
    cp++;
    if (isdigit(*cp)) {
      altfrac = (*cp++ - '0') * 10;
      if (isdigit(*cp)) {
        altfrac += (*cp++ - '0');
      }
    }
  }
  alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));
  while (!isspace(*cp) && (cp < maxcp))
    cp++;
  while (isspace(*cp) && (cp < maxcp))
    cp++;
  if (cp >= maxcp)
    goto defaults;
  siz = precsize_aton((char **)&cp);
  while (!isspace(*cp) && (cp < maxcp))
    cp++;
  while (isspace(*cp) && (cp < maxcp))
    cp++;
  if (cp >= maxcp)
    goto defaults;
  hp = precsize_aton((char **)&cp);
  while (!isspace(*cp) && (cp < maxcp))
    cp++;
  while (isspace(*cp) && (cp < maxcp))
    cp++;
  if (cp >= maxcp)
    goto defaults;
  vp = precsize_aton((char **)&cp);
defaults:
  bcp = binary;
  *bcp++ = (u_int8_t)0;
  *bcp++ = siz;
  *bcp++ = hp;
  *bcp++ = vp;
  PUTLONG(latit, bcp);
  PUTLONG(longit, bcp);
  PUTLONG(alt, bcp);
  return (16);
}


x86 assembly (clang, -O0):
<loc_aton>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x50(%rbp)
movq   $0x16,-0x58(%rbp)
movq   $0x13,-0x60(%rbp)
movq   $0x12,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x10(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
lea    -0x20(%rbp),%rdi
mov    %rdi,-0x78(%rbp)
lea    -0x6c(%rbp),%rsi
call   1040 <latlon2ul@plt>
mov    -0x78(%rbp),%rdi
mov    %eax,-0x40(%rbp)
lea    -0x70(%rbp),%rsi
call   1040 <latlon2ul@plt>
mov    %eax,-0x44(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    %ecx,%eax
sub    $0x3,%eax
jne    1294 <loc_aton+0x134>
jmp    1234 <loc_aton+0xd4>
cmpl   $0x1,-0x6c(%rbp)
jne    1259 <loc_aton+0xf9>
cmpl   $0x2,-0x70(%rbp)
jne    1259 <loc_aton+0xf9>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    128f <loc_aton+0x12f>
cmpl   $0x2,-0x6c(%rbp)
jne    127e <loc_aton+0x11e>
cmpl   $0x1,-0x70(%rbp)
jne    127e <loc_aton+0x11e>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    128a <loc_aton+0x12a>
movl   $0x0,-0x4(%rbp)
jmp    16ba <loc_aton+0x55a>
jmp    128f <loc_aton+0x12f>
jmp    12a0 <loc_aton+0x140>
movl   $0x0,-0x4(%rbp)
jmp    16ba <loc_aton+0x55a>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    12c3 <loc_aton+0x163>
movl   $0xffffffff,-0x50(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    12df <loc_aton+0x17f>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12e4 <loc_aton+0x184>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     131d <loc_aton+0x1bd>
imul   $0xa,-0x48(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
movsbl (%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
jmp    12e4 <loc_aton+0x184>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    13a5 <loc_aton+0x245>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13a0 <loc_aton+0x240>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     139b <loc_aton+0x23b>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    13a0 <loc_aton+0x240>
jmp    13a5 <loc_aton+0x245>
mov    -0x50(%rbp),%eax
imul   $0x64,-0x48(%rbp),%ecx
add    -0x4c(%rbp),%ecx
imul   %ecx,%eax
add    $0x989680,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x81(%rbp)
jne    13ec <loc_aton+0x28c>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    13ff <loc_aton+0x29f>
jmp    1410 <loc_aton+0x2b0>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    13ba <loc_aton+0x25a>
jmp    1415 <loc_aton+0x2b5>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x82(%rbp)
je     1447 <loc_aton+0x2e7>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x82(%rbp)
mov    -0x82(%rbp),%al
test   $0x1,%al
jne    145a <loc_aton+0x2fa>
jmp    146b <loc_aton+0x30b>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1415 <loc_aton+0x2b5>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     147e <loc_aton+0x31e>
jmp    162d <loc_aton+0x4cd>
lea    -0x20(%rbp),%rdi
call   1080 <precsize_aton@plt>
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x83(%rbp)
jne    14bd <loc_aton+0x35d>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x83(%rbp)
mov    -0x83(%rbp),%al
test   $0x1,%al
jne    14d0 <loc_aton+0x370>
jmp    14e1 <loc_aton+0x381>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    148b <loc_aton+0x32b>
jmp    14e6 <loc_aton+0x386>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x84(%rbp)
je     1518 <loc_aton+0x3b8>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x84(%rbp)
mov    -0x84(%rbp),%al
test   $0x1,%al
jne    152b <loc_aton+0x3cb>
jmp    153c <loc_aton+0x3dc>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    14e6 <loc_aton+0x386>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     154f <loc_aton+0x3ef>
jmp    162d <loc_aton+0x4cd>
lea    -0x20(%rbp),%rdi
call   1080 <precsize_aton@plt>
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x85(%rbp)
jne    158e <loc_aton+0x42e>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
test   $0x1,%al
jne    15a1 <loc_aton+0x441>
jmp    15b2 <loc_aton+0x452>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    155c <loc_aton+0x3fc>
jmp    15b7 <loc_aton+0x457>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x86(%rbp)
je     15e9 <loc_aton+0x489>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x86(%rbp)
mov    -0x86(%rbp),%al
test   $0x1,%al
jne    15fc <loc_aton+0x49c>
jmp    160d <loc_aton+0x4ad>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    15b7 <loc_aton+0x457>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     1620 <loc_aton+0x4c0>
jmp    162d <loc_aton+0x4cd>
lea    -0x20(%rbp),%rdi
call   1080 <precsize_aton@plt>
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movl   $0x0,(%rax)
mov    -0x68(%rbp),%rax
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x58(%rbp),%rax
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x34(%rbp),%edi
mov    -0x30(%rbp),%rsi
call   1060 <PUTLONG@plt>
mov    -0x38(%rbp),%edi
mov    -0x30(%rbp),%rsi
call   1060 <PUTLONG@plt>
mov    -0x3c(%rbp),%edi
mov    -0x30(%rbp),%rsi
call   1060 <PUTLONG@plt>
movl   $0x10,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<loc_aton>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
mov    %rdi,%rbp
movl   $0x0,0x24(%rsp)
movl   $0x0,0x20(%rsp)
mov    %rdi,0x8(%rsp)
call   1050 <strlen@plt>
mov    %eax,%r13d
lea    0x8(%rsp),%rbx
lea    0x24(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <latlon2ul@plt>
mov    %eax,%r15d
lea    0x20(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <latlon2ul@plt>
mov    %eax,%ecx
mov    0x24(%rsp),%esi
mov    0x20(%rsp),%edx
lea    (%rdx,%rsi,1),%edi
xor    %eax,%eax
cmp    $0x3,%edi
jne    14f0 <loc_aton+0x390>
cmp    $0x1,%esi
jne    11dd <loc_aton+0x7d>
cmp    $0x2,%edx
jne    11dd <loc_aton+0x7d>
mov    %r15d,%esi
mov    %ecx,%r15d
jmp    11f1 <loc_aton+0x91>
cmp    $0x2,%esi
jne    14f0 <loc_aton+0x390>
mov    %ecx,%esi
cmp    $0x1,%edx
jne    14f0 <loc_aton+0x390>
mov    0x8(%rsp),%rcx
mov    (%rcx),%al
mov    $0x1,%ebx
cmp    $0x2d,%al
jne    1215 <loc_aton+0xb5>
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
mov    0x1(%rcx),%al
mov    $0xffffffff,%ebx
mov    %rdx,%rcx
mov    %esi,0x14(%rsp)
mov    %r15d,0x18(%rsp)
cmp    $0x2b,%al
jne    122e <loc_aton+0xce>
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
mov    0x1(%rcx),%al
movsbl %al,%edi
call   1030 <isdigit@plt>
xor    %r12d,%r12d
mov    $0x0,%r15d
test   %rax,%rax
je     1282 <loc_aton+0x122>
mov    %ebx,%r12d
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    (%rbx,%rbx,4),%eax
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
movsbl (%rcx),%edx
lea    (%rdx,%rax,2),%ebx
add    $0xffffffd0,%ebx
movsbl 0x1(%rcx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    1250 <loc_aton+0xf0>
imul   $0x64,%ebx,%r15d
mov    %r12d,%ebx
xor    %r12d,%r12d
movslq %r13d,%r13
mov    0x8(%rsp),%rax
cmpb   $0x2e,(%rax)
jne    12fb <loc_aton+0x19b>
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12fb <loc_aton+0x19b>
mov    %ebx,0x1c(%rsp)
mov    0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
movsbl (%rax),%ebx
add    %ebx,%ebx
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12ec <loc_aton+0x18c>
lea    (%rbx,%rbx,4),%eax
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
movsbl (%rcx),%ecx
lea    (%rax,%rcx,1),%r12d
add    $0xfffffdf0,%r12d
jmp    12f7 <loc_aton+0x197>
lea    (%rbx,%rbx,4),%r12d
add    $0xfffffe20,%r12d
mov    0x1c(%rsp),%ebx
add    %r15d,%r12d
add    %r13,%rbp
mov    0x8(%rsp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
mov    0x8(%rsp),%rcx
test   %rax,%rax
jne    1353 <loc_aton+0x1f3>
cmp    %rbp,%rcx
jae    1353 <loc_aton+0x1f3>
mov    0x18(%rsp),%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
movsbl 0x1(%rcx),%edi
call   1070 <isspace@plt>
mov    0x8(%rsp),%rcx
test   %rax,%rax
jne    1358 <loc_aton+0x1f8>
cmp    %rbp,%rcx
jb     1330 <loc_aton+0x1d0>
jmp    1358 <loc_aton+0x1f8>
mov    0x18(%rsp),%r15d
imul   %ebx,%r12d
movsbl (%rcx),%edi
nop
call   1070 <isspace@plt>
mov    0x8(%rsp),%rdx
cmp    %rbp,%rdx
setb   %cl
test   %rax,%rax
je     1389 <loc_aton+0x229>
cmp    %rbp,%rdx
jae    1389 <loc_aton+0x229>
lea    0x1(%rdx),%rax
mov    %rax,0x8(%rsp)
movsbl 0x1(%rdx),%edi
jmp    1360 <loc_aton+0x200>
add    $0x989680,%r12d
mov    $0x12,%r13d
mov    $0x13,%eax
mov    $0x16,%ebx
test   %cl,%cl
je     14a7 <loc_aton+0x347>
lea    0x8(%rsp),%rdi
call   1080 <precsize_aton@plt>
mov    %rax,%r13
mov    0x8(%rsp),%rax
movsbl (%rax),%edi
nopl   (%rax)
call   1070 <isspace@plt>
mov    0x8(%rsp),%rcx
test   %rax,%rax
jne    13e3 <loc_aton+0x283>
cmp    %rbp,%rcx
jae    13e3 <loc_aton+0x283>
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
movsbl 0x1(%rcx),%edi
jmp    13c0 <loc_aton+0x260>
movsbl (%rcx),%edi
cs nopw 0x0(%rax,%rax,1)
call   1070 <isspace@plt>
mov    0x8(%rsp),%rcx
cmp    %rbp,%rcx
setb   %dl
test   %rax,%rax
je     1419 <loc_aton+0x2b9>
cmp    %rbp,%rcx
jae    1419 <loc_aton+0x2b9>
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
movsbl 0x1(%rcx),%edi
jmp    13f0 <loc_aton+0x290>
test   %dl,%dl
je     14ad <loc_aton+0x34d>
lea    0x8(%rsp),%rdi
call   1080 <precsize_aton@plt>
mov    %rax,%rbx
mov    0x8(%rsp),%rax
movsbl (%rax),%edi
cs nopw 0x0(%rax,%rax,1)
call   1070 <isspace@plt>
mov    0x8(%rsp),%rcx
test   %rax,%rax
jne    1463 <loc_aton+0x303>
cmp    %rbp,%rcx
jae    1463 <loc_aton+0x303>
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
movsbl 0x1(%rcx),%edi
jmp    1440 <loc_aton+0x2e0>
movsbl (%rcx),%edi
cs nopw 0x0(%rax,%rax,1)
call   1070 <isspace@plt>
mov    0x8(%rsp),%rcx
cmp    %rbp,%rcx
setb   %dl
test   %rax,%rax
je     1499 <loc_aton+0x339>
cmp    %rbp,%rcx
jae    1499 <loc_aton+0x339>
lea    0x1(%rcx),%rax
mov    %rax,0x8(%rsp)
movsbl 0x1(%rcx),%edi
jmp    1470 <loc_aton+0x310>
test   %dl,%dl
je     14ad <loc_aton+0x34d>
lea    0x8(%rsp),%rdi
call   1080 <precsize_aton@plt>
mov    0x14(%rsp),%edi
jmp    14b6 <loc_aton+0x356>
mov    0x14(%rsp),%edi
mov    $0x13,%eax
movl   $0x0,(%r14)
mov    %r13d,0x4(%r14)
mov    %ebx,0x8(%r14)
mov    %eax,0xc(%r14)
add    $0x10,%r14
mov    %r14,%rsi
call   1060 <PUTLONG@plt>
mov    %r15d,%edi
mov    %r14,%rsi
call   1060 <PUTLONG@plt>
mov    %r12d,%edi
mov    %r14,%rsi
call   1060 <PUTLONG@plt>
mov    $0x10,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @loc_aton(i8* %0, i32* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i32
%21 = alloca i32
store i8* %0, i8** %4
store i32* %1, i32** %5
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %13
store i32 0, i32* %14
store i32 0, i32* %15
store i32 1, i32* %16
store i8* inttoptr (i64 22 to i8*), i8** %17
store i8* inttoptr (i64 19 to i8*), i8** %18
store i8* inttoptr (i64 18 to i8*), i8** %19
store i32 0, i32* %20
store i32 0, i32* %21
%22 = load i8*, i8** %4
store i8* %22, i8** %6
%23 = load i8*, i8** %6
%24 = load i8*, i8** %4
%25 = call i32 @strlen(i8* %24)
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %23, i64 %26
store i8* %27, i8** %7
%28 = call i32 @latlon2ul(i8** %6, i32* %20)
store i32 %28, i32* %12
%29 = call i32 @latlon2ul(i8** %6, i32* %21)
store i32 %29, i32* %13
%30 = load i32, i32* %20
%31 = load i32, i32* %21
%32 = add nsw i32 %30, %31
switch i32 %32, label %54 [
i32 3, label %33
]
33: ; preds = %2
%34 = load i32, i32* %20
%35 = icmp eq i32 %34, 1
br i1 %35, label %36, label %42
36: ; preds = %33
%37 = load i32, i32* %21
%38 = icmp eq i32 %37, 2
br i1 %38, label %39, label %42
39: ; preds = %36
%40 = load i32, i32* %12
store i32 %40, i32* %9
%41 = load i32, i32* %13
store i32 %41, i32* %10
br label %53
42: ; preds = %36, %33
%43 = load i32, i32* %20
%44 = icmp eq i32 %43, 2
br i1 %44, label %45, label %51
45: ; preds = %42
%46 = load i32, i32* %21
%47 = icmp eq i32 %46, 1
br i1 %47, label %48, label %51
48: ; preds = %45
%49 = load i32, i32* %12
store i32 %49, i32* %10
%50 = load i32, i32* %13
store i32 %50, i32* %9
br label %52
51: ; preds = %45, %42
store i32 0, i32* %3
br label %260
52: ; preds = %48
br label %53
53: ; preds = %52, %39
br label %55
54: ; preds = %2
store i32 0, i32* %3
br label %260
55: ; preds = %53
%56 = load i8*, i8** %6
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp eq i32 %58, 45
br i1 %59, label %60, label %63
60: ; preds = %55
store i32 -1, i32* %16
%61 = load i8*, i8** %6
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %6
br label %63
63: ; preds = %60, %55
%64 = load i8*, i8** %6
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = icmp eq i32 %66, 43
br i1 %67, label %68, label %71
68: ; preds = %63
%69 = load i8*, i8** %6
%70 = getelementptr inbounds i8, i8* %69, i32 1
store i8* %70, i8** %6
br label %71
71: ; preds = %68, %63
br label %72
72: ; preds = %77, %71
%73 = load i8*, i8** %6
%74 = load i8, i8* %73
%75 = call i64 @isdigit(i8 signext %74)
%76 = icmp ne i64 %75, 0
br i1 %76, label %77, label %86
77: ; preds = %72
%78 = load i32, i32* %14
%79 = mul nsw i32 %78, 10
%80 = load i8*, i8** %6
%81 = getelementptr inbounds i8, i8* %80, i32 1
store i8* %81, i8** %6
%82 = load i8, i8* %80
%83 = sext i8 %82 to i32
%84 = sub nsw i32 %83, 48
%85 = add nsw i32 %79, %84
store i32 %85, i32* %14
br label %72
86: ; preds = %72
%87 = load i8*, i8** %6
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = icmp eq i32 %89, 46
br i1 %90, label %91, label %119
91: ; preds = %86
%92 = load i8*, i8** %6
%93 = getelementptr inbounds i8, i8* %92, i32 1
store i8* %93, i8** %6
%94 = load i8*, i8** %6
%95 = load i8, i8* %94
%96 = call i64 @isdigit(i8 signext %95)
%97 = icmp ne i64 %96, 0
br i1 %97, label %98, label %118
98: ; preds = %91
%99 = load i8*, i8** %6
%100 = getelementptr inbounds i8, i8* %99, i32 1
store i8* %100, i8** %6
%101 = load i8, i8* %99
%102 = sext i8 %101 to i32
%103 = sub nsw i32 %102, 48
%104 = mul nsw i32 %103, 10
store i32 %104, i32* %15
%105 = load i8*, i8** %6
%106 = load i8, i8* %105
%107 = call i64 @isdigit(i8 signext %106)
%108 = icmp ne i64 %107, 0
br i1 %108, label %109, label %117
109: ; preds = %98
%110 = load i8*, i8** %6
%111 = getelementptr inbounds i8, i8* %110, i32 1
store i8* %111, i8** %6
%112 = load i8, i8* %110
%113 = sext i8 %112 to i32
%114 = sub nsw i32 %113, 48
%115 = load i32, i32* %15
%116 = add nsw i32 %115, %114
store i32 %116, i32* %15
br label %117
117: ; preds = %109, %98
br label %118
118: ; preds = %117, %91
br label %119
119: ; preds = %118, %86
%120 = load i32, i32* %16
%121 = load i32, i32* %14
%122 = mul nsw i32 %121, 100
%123 = load i32, i32* %15
%124 = add nsw i32 %122, %123
%125 = mul nsw i32 %120, %124
%126 = add nsw i32 10000000, %125
store i32 %126, i32* %11
br label %127
127: ; preds = %138, %119
%128 = load i8*, i8** %6
%129 = load i8, i8* %128
%130 = call i64 @isspace(i8 signext %129)
%131 = icmp ne i64 %130, 0
br i1 %131, label %136, label %132
132: ; preds = %127
%133 = load i8*, i8** %6
%134 = load i8*, i8** %7
%135 = icmp ult i8* %133, %134
br label %136
136: ; preds = %132, %127
%137 = phi i1 [ false, %127 ], [ %135, %132 ]
br i1 %137, label %138, label %141
138: ; preds = %136
%139 = load i8*, i8** %6
%140 = getelementptr inbounds i8, i8* %139, i32 1
store i8* %140, i8** %6
br label %127
141: ; preds = %136
br label %142
142: ; preds = %153, %141
%143 = load i8*, i8** %6
%144 = load i8, i8* %143
%145 = call i64 @isspace(i8 signext %144)
%146 = icmp ne i64 %145, 0
br i1 %146, label %147, label %151
147: ; preds = %142
%148 = load i8*, i8** %6
%149 = load i8*, i8** %7
%150 = icmp ult i8* %148, %149
br label %151
151: ; preds = %147, %142
%152 = phi i1 [ false, %142 ], [ %150, %147 ]
br i1 %152, label %153, label %156
153: ; preds = %151
%154 = load i8*, i8** %6
%155 = getelementptr inbounds i8, i8* %154, i32 1
store i8* %155, i8** %6
br label %142
156: ; preds = %151
%157 = load i8*, i8** %6
%158 = load i8*, i8** %7
%159 = icmp uge i8* %157, %158
br i1 %159, label %160, label %161
160: ; preds = %156
br label %235
161: ; preds = %156
%162 = call i8* @precsize_aton(i8** %6)
store i8* %162, i8** %19
br label %163
163: ; preds = %174, %161
%164 = load i8*, i8** %6
%165 = load i8, i8* %164
%166 = call i64 @isspace(i8 signext %165)
%167 = icmp ne i64 %166, 0
br i1 %167, label %172, label %168
168: ; preds = %163
%169 = load i8*, i8** %6
%170 = load i8*, i8** %7
%171 = icmp ult i8* %169, %170
br label %172
172: ; preds = %168, %163
%173 = phi i1 [ false, %163 ], [ %171, %168 ]
br i1 %173, label %174, label %177
174: ; preds = %172
%175 = load i8*, i8** %6
%176 = getelementptr inbounds i8, i8* %175, i32 1
store i8* %176, i8** %6
br label %163
177: ; preds = %172
br label %178
178: ; preds = %189, %177
%179 = load i8*, i8** %6
%180 = load i8, i8* %179
%181 = call i64 @isspace(i8 signext %180)
%182 = icmp ne i64 %181, 0
br i1 %182, label %183, label %187
183: ; preds = %178
%184 = load i8*, i8** %6
%185 = load i8*, i8** %7
%186 = icmp ult i8* %184, %185
br label %187
187: ; preds = %183, %178
%188 = phi i1 [ false, %178 ], [ %186, %183 ]
br i1 %188, label %189, label %192
189: ; preds = %187
%190 = load i8*, i8** %6
%191 = getelementptr inbounds i8, i8* %190, i32 1
store i8* %191, i8** %6
br label %178
192: ; preds = %187
%193 = load i8*, i8** %6
%194 = load i8*, i8** %7
%195 = icmp uge i8* %193, %194
br i1 %195, label %196, label %197
196: ; preds = %192
br label %235
197: ; preds = %192
%198 = call i8* @precsize_aton(i8** %6)
store i8* %198, i8** %17
br label %199
199: ; preds = %210, %197
%200 = load i8*, i8** %6
%201 = load i8, i8* %200
%202 = call i64 @isspace(i8 signext %201)
%203 = icmp ne i64 %202, 0
br i1 %203, label %208, label %204
204: ; preds = %199
%205 = load i8*, i8** %6
%206 = load i8*, i8** %7
%207 = icmp ult i8* %205, %206
br label %208
208: ; preds = %204, %199
%209 = phi i1 [ false, %199 ], [ %207, %204 ]
br i1 %209, label %210, label %213
210: ; preds = %208
%211 = load i8*, i8** %6
%212 = getelementptr inbounds i8, i8* %211, i32 1
store i8* %212, i8** %6
br label %199
213: ; preds = %208
br label %214
214: ; preds = %225, %213
%215 = load i8*, i8** %6
%216 = load i8, i8* %215
%217 = call i64 @isspace(i8 signext %216)
%218 = icmp ne i64 %217, 0
br i1 %218, label %219, label %223
219: ; preds = %214
%220 = load i8*, i8** %6
%221 = load i8*, i8** %7
%222 = icmp ult i8* %220, %221
br label %223
223: ; preds = %219, %214
%224 = phi i1 [ false, %214 ], [ %222, %219 ]
br i1 %224, label %225, label %228
225: ; preds = %223
%226 = load i8*, i8** %6
%227 = getelementptr inbounds i8, i8* %226, i32 1
store i8* %227, i8** %6
br label %214
228: ; preds = %223
%229 = load i8*, i8** %6
%230 = load i8*, i8** %7
%231 = icmp uge i8* %229, %230
br i1 %231, label %232, label %233
232: ; preds = %228
br label %235
233: ; preds = %228
%234 = call i8* @precsize_aton(i8** %6)
store i8* %234, i8** %18
br label %235
235: ; preds = %233, %232, %196, %160
%236 = load i32*, i32** %5
store i32* %236, i32** %8
%237 = load i32*, i32** %8
%238 = getelementptr inbounds i32, i32* %237, i32 1
store i32* %238, i32** %8
store i32 0, i32* %237
%239 = load i8*, i8** %19
%240 = ptrtoint i8* %239 to i32
%241 = load i32*, i32** %8
%242 = getelementptr inbounds i32, i32* %241, i32 1
store i32* %242, i32** %8
store i32 %240, i32* %241
%243 = load i8*, i8** %17
%244 = ptrtoint i8* %243 to i32
%245 = load i32*, i32** %8
%246 = getelementptr inbounds i32, i32* %245, i32 1
store i32* %246, i32** %8
store i32 %244, i32* %245
%247 = load i8*, i8** %18
%248 = ptrtoint i8* %247 to i32
%249 = load i32*, i32** %8
%250 = getelementptr inbounds i32, i32* %249, i32 1
store i32* %250, i32** %8
store i32 %248, i32* %249
%251 = load i32, i32* %9
%252 = load i32*, i32** %8
%253 = call i32 @PUTLONG(i32 %251, i32* %252)
%254 = load i32, i32* %10
%255 = load i32*, i32** %8
%256 = call i32 @PUTLONG(i32 %254, i32* %255)
%257 = load i32, i32* %11
%258 = load i32*, i32** %8
%259 = call i32 @PUTLONG(i32 %257, i32* %258)
store i32 16, i32* %3
br label %260
260: ; preds = %235, %54, %51
%261 = load i32, i32* %3
ret i32 %261
}

LLVM IR (-O2):
define i32 @loc_aton(i8* %0, i32* %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = bitcast i8** %3 to i8*
%7 = bitcast i32* %4 to i8*
store i32 0, i32* %4
%8 = bitcast i32* %5 to i8*
store i32 0, i32* %5
store i8* %0, i8** %3
%9 = tail call i32 @strlen(i8* %0)
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds i8, i8* %0, i64 %10
%12 = call i32 @latlon2ul(i8** %3, i32* %4)
%13 = call i32 @latlon2ul(i8** %3, i32* %5)
%14 = load i32, i32* %4
%15 = load i32, i32* %5
%16 = add nsw i32 %15, %14
%17 = icmp eq i32 %16, 3
br i1 %17, label %18, label %221
18: ; preds = %2
%19 = icmp eq i32 %14, 1
%20 = icmp eq i32 %15, 2
%21 = select i1 %19, i1 %20, i1 false
br i1 %21, label %26, label %22
22: ; preds = %18
%23 = icmp eq i32 %14, 2
%24 = icmp eq i32 %15, 1
%25 = select i1 %23, i1 %24, i1 false
br i1 %25, label %26, label %221
26: ; preds = %22, %18
%27 = phi i32 [ %12, %18 ], [ %13, %22 ]
%28 = phi i32 [ %13, %18 ], [ %12, %22 ]
%29 = load i8*, i8** %3
%30 = load i8, i8* %29
%31 = icmp eq i8 %30, 45
br i1 %31, label %32, label %35
32: ; preds = %26
%33 = getelementptr inbounds i8, i8* %29, i64 1
store i8* %33, i8** %3
%34 = load i8, i8* %33
br label %35
35: ; preds = %32, %26
%36 = phi i8 [ %34, %32 ], [ %30, %26 ]
%37 = phi i8* [ %33, %32 ], [ %29, %26 ]
%38 = phi i32 [ -1, %32 ], [ 1, %26 ]
%39 = icmp eq i8 %36, 43
br i1 %39, label %40, label %43
40: ; preds = %35
%41 = getelementptr inbounds i8, i8* %37, i64 1
store i8* %41, i8** %3
%42 = load i8, i8* %41
br label %43
43: ; preds = %40, %35
%44 = phi i8 [ %42, %40 ], [ %36, %35 ]
%45 = call i64 @isdigit(i8 signext %44)
%46 = icmp eq i64 %45, 0
br i1 %46, label %61, label %47
47: ; preds = %43, %47
%48 = phi i32 [ %55, %47 ], [ 0, %43 ]
%49 = mul nsw i32 %48, 10
%50 = load i8*, i8** %3
%51 = getelementptr inbounds i8, i8* %50, i64 1
store i8* %51, i8** %3
%52 = load i8, i8* %50
%53 = sext i8 %52 to i32
%54 = add i32 %49, -48
%55 = add i32 %54, %53
%56 = load i8, i8* %51
%57 = call i64 @isdigit(i8 signext %56)
%58 = icmp eq i64 %57, 0
br i1 %58, label %59, label %47
59: ; preds = %47
%60 = mul i32 %55, 100
br label %61
61: ; preds = %59, %43
%62 = phi i32 [ 0, %43 ], [ %60, %59 ]
%63 = load i8*, i8** %3
%64 = load i8, i8* %63
%65 = icmp eq i8 %64, 46
br i1 %65, label %66, label %88
66: ; preds = %61
%67 = getelementptr inbounds i8, i8* %63, i64 1
store i8* %67, i8** %3
%68 = load i8, i8* %67
%69 = call i64 @isdigit(i8 signext %68)
%70 = icmp eq i64 %69, 0
br i1 %70, label %88, label %71
71: ; preds = %66
%72 = load i8*, i8** %3
%73 = getelementptr inbounds i8, i8* %72, i64 1
store i8* %73, i8** %3
%74 = load i8, i8* %72
%75 = sext i8 %74 to i32
%76 = mul nsw i32 %75, 10
%77 = add nsw i32 %76, -480
%78 = load i8, i8* %73
%79 = call i64 @isdigit(i8 signext %78)
%80 = icmp eq i64 %79, 0
br i1 %80, label %88, label %81
81: ; preds = %71
%82 = load i8*, i8** %3
%83 = getelementptr inbounds i8, i8* %82, i64 1
store i8* %83, i8** %3
%84 = load i8, i8* %82
%85 = sext i8 %84 to i32
%86 = add nsw i32 %76, -528
%87 = add nsw i32 %86, %85
br label %88
88: ; preds = %66, %81, %71, %61
%89 = phi i32 [ %87, %81 ], [ %77, %71 ], [ 0, %66 ], [ 0, %61 ]
%90 = add nsw i32 %89, %62
%91 = mul nsw i32 %90, %38
%92 = add nsw i32 %91, 10000000
%93 = load i8*, i8** %3
%94 = load i8, i8* %93
%95 = call i64 @isspace(i8 signext %94)
%96 = icmp eq i64 %95, 0
%97 = load i8*, i8** %3
%98 = icmp ult i8* %97, %11
%99 = select i1 %96, i1 %98, i1 false
br i1 %99, label %108, label %100
100: ; preds = %108, %88
%101 = phi i8* [ %97, %88 ], [ %114, %108 ]
%102 = load i8, i8* %101
%103 = call i64 @isspace(i8 signext %102)
%104 = icmp ne i64 %103, 0
%105 = load i8*, i8** %3
%106 = icmp ult i8* %105, %11
%107 = select i1 %104, i1 %106, i1 false
br i1 %107, label %117, label %126
108: ; preds = %88, %108
%109 = phi i8* [ %114, %108 ], [ %97, %88 ]
%110 = getelementptr inbounds i8, i8* %109, i64 1
store i8* %110, i8** %3
%111 = load i8, i8* %110
%112 = call i64 @isspace(i8 signext %111)
%113 = icmp eq i64 %112, 0
%114 = load i8*, i8** %3
%115 = icmp ult i8* %114, %11
%116 = select i1 %113, i1 %115, i1 false
br i1 %116, label %108, label %100
117: ; preds = %100, %117
%118 = phi i8* [ %123, %117 ], [ %105, %100 ]
%119 = getelementptr inbounds i8, i8* %118, i64 1
store i8* %119, i8** %3
%120 = load i8, i8* %119
%121 = call i64 @isspace(i8 signext %120)
%122 = icmp ne i64 %121, 0
%123 = load i8*, i8** %3
%124 = icmp ult i8* %123, %11
%125 = select i1 %122, i1 %124, i1 false
br i1 %125, label %117, label %126
126: ; preds = %117, %100
%127 = phi i1 [ %106, %100 ], [ %124, %117 ]
br i1 %127, label %128, label %204
128: ; preds = %126
%129 = call i8* @precsize_aton(i8** %3)
%130 = load i8*, i8** %3
%131 = load i8, i8* %130
%132 = call i64 @isspace(i8 signext %131)
%133 = icmp eq i64 %132, 0
%134 = load i8*, i8** %3
%135 = icmp ult i8* %134, %11
%136 = select i1 %133, i1 %135, i1 false
br i1 %136, label %145, label %137
137: ; preds = %145, %128
%138 = phi i8* [ %134, %128 ], [ %151, %145 ]
%139 = load i8, i8* %138
%140 = call i64 @isspace(i8 signext %139)
%141 = icmp ne i64 %140, 0
%142 = load i8*, i8** %3
%143 = icmp ult i8* %142, %11
%144 = select i1 %141, i1 %143, i1 false
br i1 %144, label %154, label %163
145: ; preds = %128, %145
%146 = phi i8* [ %151, %145 ], [ %134, %128 ]
%147 = getelementptr inbounds i8, i8* %146, i64 1
store i8* %147, i8** %3
%148 = load i8, i8* %147
%149 = call i64 @isspace(i8 signext %148)
%150 = icmp eq i64 %149, 0
%151 = load i8*, i8** %3
%152 = icmp ult i8* %151, %11
%153 = select i1 %150, i1 %152, i1 false
br i1 %153, label %145, label %137
154: ; preds = %137, %154
%155 = phi i8* [ %160, %154 ], [ %142, %137 ]
%156 = getelementptr inbounds i8, i8* %155, i64 1
store i8* %156, i8** %3
%157 = load i8, i8* %156
%158 = call i64 @isspace(i8 signext %157)
%159 = icmp ne i64 %158, 0
%160 = load i8*, i8** %3
%161 = icmp ult i8* %160, %11
%162 = select i1 %159, i1 %161, i1 false
br i1 %162, label %154, label %163
163: ; preds = %154, %137
%164 = phi i1 [ %143, %137 ], [ %161, %154 ]
br i1 %164, label %165, label %204
165: ; preds = %163
%166 = call i8* @precsize_aton(i8** %3)
%167 = load i8*, i8** %3
%168 = load i8, i8* %167
%169 = call i64 @isspace(i8 signext %168)
%170 = icmp eq i64 %169, 0
%171 = load i8*, i8** %3
%172 = icmp ult i8* %171, %11
%173 = select i1 %170, i1 %172, i1 false
br i1 %173, label %182, label %174
174: ; preds = %182, %165
%175 = phi i8* [ %171, %165 ], [ %188, %182 ]
%176 = load i8, i8* %175
%177 = call i64 @isspace(i8 signext %176)
%178 = icmp ne i64 %177, 0
%179 = load i8*, i8** %3
%180 = icmp ult i8* %179, %11
%181 = select i1 %178, i1 %180, i1 false
br i1 %181, label %191, label %200
182: ; preds = %165, %182
%183 = phi i8* [ %188, %182 ], [ %171, %165 ]
%184 = getelementptr inbounds i8, i8* %183, i64 1
store i8* %184, i8** %3
%185 = load i8, i8* %184
%186 = call i64 @isspace(i8 signext %185)
%187 = icmp eq i64 %186, 0
%188 = load i8*, i8** %3
%189 = icmp ult i8* %188, %11
%190 = select i1 %187, i1 %189, i1 false
br i1 %190, label %182, label %174
191: ; preds = %174, %191
%192 = phi i8* [ %197, %191 ], [ %179, %174 ]
%193 = getelementptr inbounds i8, i8* %192, i64 1
store i8* %193, i8** %3
%194 = load i8, i8* %193
%195 = call i64 @isspace(i8 signext %194)
%196 = icmp ne i64 %195, 0
%197 = load i8*, i8** %3
%198 = icmp ult i8* %197, %11
%199 = select i1 %196, i1 %198, i1 false
br i1 %199, label %191, label %200
200: ; preds = %191, %174
%201 = phi i1 [ %180, %174 ], [ %198, %191 ]
br i1 %201, label %202, label %204
202: ; preds = %200
%203 = call i8* @precsize_aton(i8** %3)
br label %204
204: ; preds = %200, %163, %126, %202
%205 = phi i8* [ inttoptr (i64 22 to i8*), %126 ], [ inttoptr (i64 22 to i8*), %163 ], [ %166, %200 ], [ %166, %202 ]
%206 = phi i8* [ inttoptr (i64 19 to i8*), %126 ], [ inttoptr (i64 19 to i8*), %163 ], [ inttoptr (i64 19 to i8*), %200 ], [ %203, %202 ]
%207 = phi i8* [ inttoptr (i64 18 to i8*), %126 ], [ %129, %163 ], [ %129, %200 ], [ %129, %202 ]
%208 = getelementptr inbounds i32, i32* %1, i64 1
store i32 0, i32* %1
%209 = ptrtoint i8* %207 to i64
%210 = trunc i64 %209 to i32
%211 = getelementptr inbounds i32, i32* %1, i64 2
store i32 %210, i32* %208
%212 = ptrtoint i8* %205 to i64
%213 = trunc i64 %212 to i32
%214 = getelementptr inbounds i32, i32* %1, i64 3
store i32 %213, i32* %211
%215 = ptrtoint i8* %206 to i64
%216 = trunc i64 %215 to i32
%217 = getelementptr inbounds i32, i32* %1, i64 4
store i32 %216, i32* %214
%218 = call i32 @PUTLONG(i32 %27, i32* %217)
%219 = call i32 @PUTLONG(i32 %28, i32* %217)
%220 = call i32 @PUTLONG(i32 %92, i32* %217)
br label %221
221: ; preds = %2, %22, %204
%222 = phi i32 [ 16, %204 ], [ 0, %22 ], [ 0, %2 ]
ret i32 %222
}