#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 */
struct tm {
  scalar_t__ tm_hour;
  int tm_mday;
  scalar_t__ tm_year;
  void *tm_wday;
  void *tm_sec;
  void *tm_min;
  scalar_t__ tm_mon;
  void *tm_yday;
  scalar_t__ tm_isdst;
};
typedef int /*<<< orphan*/ buffer;

/* Variables and functions */
void *atoi(char *);
int /*<<< orphan*/ isalpha(char);
int /*<<< orphan*/ isdigit(char);
int /*<<< orphan*/ isspace(char);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ strlen(char *);
int /*<<< orphan*/ strncmp(char *, char *, int);
char *Strptime_Strptime(char *s, char *format, struct tm *tm) {
  char *t;
  char *m;
  char buffer[256];
  int i;
  int century;
  int period;
  int error;
  t = s;
  m = format;
  tm->tm_sec = 0;
  tm->tm_min = 0;
  tm->tm_hour = 0;
  tm->tm_mday = 1;
  tm->tm_mon = 0;
  tm->tm_year = 0;
  tm->tm_wday = 0;
  tm->tm_yday = 0;
  tm->tm_isdst = 0;
  century = 0;
  period = 0;
  error = 0;
  while (*m) {
    memset(buffer, 0, sizeof(buffer));
    if (*m == '%') {
      m++;
      switch (*m) {
      case 'a':
        error = 1;
        break;
      case 'A':
        error = 1;
        break;
      case 'b':
        error = 1;
        break;
      case 'B':
        error = 1;
        break;
      case 'h':
        error = 1;
        break;
      case 'c':
        error = 1;
        break;
      case 'C':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          century = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 'd':
      case 'e':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_mday = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 'D':
        error = 1;
        break;
      case 'H':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_hour = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 'I':
        error = 1;
        break;
      case 'j':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_yday = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 'm':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_mon = atoi(buffer) - 1;
        } else {
          error = 1;
        }
        break;
      case 'M':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_min = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 'n':
        while (*t) {
          if (isspace(*t)) {
            t++;
          } else {
            break;
          }
        }
        break;
      case 'p':
        i = 0;
        while (*t) {
          if (isalpha(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strncmp("am", buffer, 2) == 0) {
          period = 0;
        } else if (strncmp("pm", buffer, 2) == 0) {
          period = 1;
        } else {
          error = 1;
        }
        if (tm->tm_hour > 0) {
          tm->tm_hour = tm->tm_hour + 12 * period;
        }
        break;
      case 'r':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_hour = atoi(buffer) + 12 * period;
        } else {
          error = 1;
        }
        break;
      case 'R':
        error = 1;
        break;
      case 'S':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_sec = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 't':
        while (*t) {
          if (isspace(*t)) {
            t++;
          } else {
            break;
          }
        }
        break;
      case 'T':
        error = 1;
        break;
      case 'U':
        error = 1;
        break;
      case 'w':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_wday = atoi(buffer);
        } else {
          error = 1;
        }
        break;
      case 'W':
        error = 1;
        break;
      case 'x':
        error = 1;
        break;
      case 'X':
        error = 1;
        break;
      case 'y':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_year = atoi(buffer);
          if (century == 0) {
            if ((tm->tm_year >= 0) && (tm->tm_year <= 68)) {
              tm->tm_year = tm->tm_year + 100;
            } else if ((tm->tm_year >= 69) && (tm->tm_year <= 99)) {
              tm->tm_year = tm->tm_year;
            }
          } else {
            tm->tm_year = tm->tm_year + century * 100;
          }
        } else {
          error = 1;
        }
        break;
      case 'Y':
        i = 0;
        while (*t) {
          if (isdigit(*t)) {
            buffer[i] = *t;
            i++;
            t++;
          } else {
            break;
          }
        }
        buffer[i] = '\0';
        if (strlen(buffer) > 0) {
          tm->tm_year = atoi(buffer) - 1900;
        } else {
          error = 1;
        }
        break;
      default:
        if (*t == *m) {
          t++;
          m++;
        } else {
          error = 1;
        }
        break;
      }
      m++;
    } else {
      if (*t == *m) {
        t++;
        m++;
      } else {
        error = 1;
      }
    }
    if (error) {
      break;
    }
  }
  return t;
}


x86 assembly (clang, -O0):
<Strptime_Strptime>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movq   $0x0,0x20(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x28(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movl   $0x1,0x8(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x30(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x10(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x18(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x38(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,0x40(%rax)
movl   $0x0,-0x138(%rbp)
movl   $0x0,-0x13c(%rbp)
movl   $0x0,-0x140(%rbp)
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1e48 <Strptime_Strptime+0xcd8>
lea    -0x130(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1060 <memset@plt>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x25,%eax
jne    1def <Strptime_Strptime+0xc7f>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x148(%rbp)
sub    $0x38,%eax
ja     1d9c <Strptime_Strptime+0xc2c>
mov    -0x148(%rbp),%rax
lea    0xd7b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1352 <Strptime_Strptime+0x1e2>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1348 <Strptime_Strptime+0x1d8>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    134d <Strptime_Strptime+0x1dd>
jmp    1352 <Strptime_Strptime+0x1e2>
jmp    12f2 <Strptime_Strptime+0x182>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    138d <Strptime_Strptime+0x21d>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %eax,-0x138(%rbp)
jmp    1397 <Strptime_Strptime+0x227>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1406 <Strptime_Strptime+0x296>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     13fc <Strptime_Strptime+0x28c>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1401 <Strptime_Strptime+0x291>
jmp    1406 <Strptime_Strptime+0x296>
jmp    13a6 <Strptime_Strptime+0x236>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1444 <Strptime_Strptime+0x2d4>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
jmp    144e <Strptime_Strptime+0x2de>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     14cc <Strptime_Strptime+0x35c>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     14c2 <Strptime_Strptime+0x352>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    14c7 <Strptime_Strptime+0x357>
jmp    14cc <Strptime_Strptime+0x35c>
jmp    146c <Strptime_Strptime+0x2fc>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    150b <Strptime_Strptime+0x39b>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
jmp    1515 <Strptime_Strptime+0x3a5>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1593 <Strptime_Strptime+0x423>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1589 <Strptime_Strptime+0x419>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    158e <Strptime_Strptime+0x41e>
jmp    1593 <Strptime_Strptime+0x423>
jmp    1533 <Strptime_Strptime+0x3c3>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    15d3 <Strptime_Strptime+0x463>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x38(%rax)
jmp    15dd <Strptime_Strptime+0x46d>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     164c <Strptime_Strptime+0x4dc>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1642 <Strptime_Strptime+0x4d2>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1647 <Strptime_Strptime+0x4d7>
jmp    164c <Strptime_Strptime+0x4dc>
jmp    15ec <Strptime_Strptime+0x47c>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1690 <Strptime_Strptime+0x520>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x30(%rax)
jmp    169a <Strptime_Strptime+0x52a>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1709 <Strptime_Strptime+0x599>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     16ff <Strptime_Strptime+0x58f>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1704 <Strptime_Strptime+0x594>
jmp    1709 <Strptime_Strptime+0x599>
jmp    16a9 <Strptime_Strptime+0x539>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1749 <Strptime_Strptime+0x5d9>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x28(%rax)
jmp    1753 <Strptime_Strptime+0x5e3>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
jmp    175d <Strptime_Strptime+0x5ed>
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     179a <Strptime_Strptime+0x62a>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
cmp    $0x0,%eax
je     1790 <Strptime_Strptime+0x620>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1795 <Strptime_Strptime+0x625>
jmp    179a <Strptime_Strptime+0x62a>
jmp    175d <Strptime_Strptime+0x5ed>
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1809 <Strptime_Strptime+0x699>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1080 <isalpha@plt>
cmp    $0x0,%eax
je     17ff <Strptime_Strptime+0x68f>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1804 <Strptime_Strptime+0x694>
jmp    1809 <Strptime_Strptime+0x699>
jmp    17a9 <Strptime_Strptime+0x639>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rsi
lea    0x8be(%rip),%rdi
mov    $0x2,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    1848 <Strptime_Strptime+0x6d8>
movl   $0x0,-0x13c(%rbp)
jmp    1887 <Strptime_Strptime+0x717>
lea    -0x130(%rbp),%rsi
lea    0x891(%rip),%rdi
mov    $0x2,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    1878 <Strptime_Strptime+0x708>
movl   $0x1,-0x13c(%rbp)
jmp    1882 <Strptime_Strptime+0x712>
movl   $0x1,-0x140(%rbp)
jmp    1887 <Strptime_Strptime+0x717>
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jle    18af <Strptime_Strptime+0x73f>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
imul   $0xc,-0x13c(%rbp),%eax
cltq
add    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     191e <Strptime_Strptime+0x7ae>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1914 <Strptime_Strptime+0x7a4>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1919 <Strptime_Strptime+0x7a9>
jmp    191e <Strptime_Strptime+0x7ae>
jmp    18be <Strptime_Strptime+0x74e>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1969 <Strptime_Strptime+0x7f9>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
imul   $0xc,-0x13c(%rbp),%eax
cltq
add    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
jmp    1973 <Strptime_Strptime+0x803>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     19f1 <Strptime_Strptime+0x881>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     19e7 <Strptime_Strptime+0x877>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    19ec <Strptime_Strptime+0x87c>
jmp    19f1 <Strptime_Strptime+0x881>
jmp    1991 <Strptime_Strptime+0x821>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1a31 <Strptime_Strptime+0x8c1>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x20(%rax)
jmp    1a3b <Strptime_Strptime+0x8cb>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
jmp    1a45 <Strptime_Strptime+0x8d5>
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1a82 <Strptime_Strptime+0x912>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
cmp    $0x0,%eax
je     1a78 <Strptime_Strptime+0x908>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1a7d <Strptime_Strptime+0x90d>
jmp    1a82 <Strptime_Strptime+0x912>
jmp    1a45 <Strptime_Strptime+0x8d5>
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1b0f <Strptime_Strptime+0x99f>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1b05 <Strptime_Strptime+0x995>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1b0a <Strptime_Strptime+0x99a>
jmp    1b0f <Strptime_Strptime+0x99f>
jmp    1aaf <Strptime_Strptime+0x93f>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1b4f <Strptime_Strptime+0x9df>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x18(%rax)
jmp    1b59 <Strptime_Strptime+0x9e9>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1bf5 <Strptime_Strptime+0xa85>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1beb <Strptime_Strptime+0xa7b>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1bf0 <Strptime_Strptime+0xa80>
jmp    1bf5 <Strptime_Strptime+0xa85>
jmp    1b95 <Strptime_Strptime+0xa25>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1ccd <Strptime_Strptime+0xb5d>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
cmpl   $0x0,-0x138(%rbp)
jne    1cac <Strptime_Strptime+0xb3c>
mov    -0x18(%rbp),%rax
cmpq   $0x0,0x10(%rax)
jl     1c74 <Strptime_Strptime+0xb04>
mov    -0x18(%rbp),%rax
cmpq   $0x44,0x10(%rax)
jg     1c74 <Strptime_Strptime+0xb04>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rcx
add    $0x64,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
jmp    1ca7 <Strptime_Strptime+0xb37>
mov    -0x18(%rbp),%rax
cmpq   $0x45,0x10(%rax)
jl     1ca2 <Strptime_Strptime+0xb32>
mov    -0x18(%rbp),%rax
cmpq   $0x63,0x10(%rax)
jg     1ca2 <Strptime_Strptime+0xb32>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
jmp    1ca7 <Strptime_Strptime+0xb37>
jmp    1cc8 <Strptime_Strptime+0xb58>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rcx
imul   $0x64,-0x138(%rbp),%eax
cltq
add    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
jmp    1cd7 <Strptime_Strptime+0xb67>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1d46 <Strptime_Strptime+0xbd6>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%eax
je     1d3c <Strptime_Strptime+0xbcc>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
movslq -0x134(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1d41 <Strptime_Strptime+0xbd1>
jmp    1d46 <Strptime_Strptime+0xbd6>
jmp    1ce6 <Strptime_Strptime+0xb76>
movslq -0x134(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
lea    -0x130(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
jle    1d8d <Strptime_Strptime+0xc1d>
lea    -0x130(%rbp),%rdi
call   1090 <atoi@plt>
mov    %rax,%rcx
add    $0xfffffffffffff894,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
jmp    1d97 <Strptime_Strptime+0xc27>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
mov    -0x28(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1dcf <Strptime_Strptime+0xc5f>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1dd9 <Strptime_Strptime+0xc69>
movl   $0x1,-0x140(%rbp)
jmp    1dde <Strptime_Strptime+0xc6e>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1e31 <Strptime_Strptime+0xcc1>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
mov    -0x28(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1e22 <Strptime_Strptime+0xcb2>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1e2c <Strptime_Strptime+0xcbc>
movl   $0x1,-0x140(%rbp)
jmp    1e31 <Strptime_Strptime+0xcc1>
cmpl   $0x0,-0x140(%rbp)
je     1e43 <Strptime_Strptime+0xcd3>
jmp    1e48 <Strptime_Strptime+0xcd8>
jmp    121f <Strptime_Strptime+0xaf>
mov    -0x20(%rbp),%rax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Strptime_Strptime>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,%rbx
lea    0x20(%rdx),%rax
mov    %rax,0x28(%rsp)
movq   $0x0,(%rdx)
xorps  %xmm0,%xmm0
movups %xmm0,0x20(%rdx)
movl   $0x1,0x8(%rdx)
lea    0x30(%rdx),%rax
mov    %rax,0x20(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,0x8(%rsp)
movups %xmm0,0x10(%rdx)
movups %xmm0,0x30(%rdx)
movq   $0x0,0x40(%rdx)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
lea    0x30(%rsp),%rbp
xor    %eax,%eax
mov    %rax,0x18(%rsp)
jmp    11f6 <Strptime_Strptime+0x86>
nop
xor    %r12d,%r12d
mov    %r13,%r15
add    $0x1,%r15
mov    %r15,%r13
test   %r12d,%r12d
jne    1849 <Strptime_Strptime+0x6d9>
cmpb   $0x0,0x0(%r13)
je     1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1060 <memset@plt>
mov    0x0(%r13),%al
cmp    $0x25,%al
jne    12b0 <Strptime_Strptime+0x140>
movsbl 0x1(%r13),%eax
lea    -0x41(%rax),%ecx
cmp    $0x38,%ecx
ja     1325 <Strptime_Strptime+0x1b5>
lea    0x1(%r13),%r15
lea    0xdc8(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1274 <Strptime_Strptime+0x104>
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     1271 <Strptime_Strptime+0x101>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1250 <Strptime_Strptime+0xe0>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %eax,0x8(%r14)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %al,(%rbx)
jne    1849 <Strptime_Strptime+0x6d9>
add    $0x1,%rbx
jmp    11e0 <Strptime_Strptime+0x70>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     12f4 <Strptime_Strptime+0x184>
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     12f1 <Strptime_Strptime+0x181>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    12d0 <Strptime_Strptime+0x160>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
cmp    %al,(%rbx)
jne    1849 <Strptime_Strptime+0x6d9>
add    $0x1,%rbx
add    $0x2,%r13
jmp    11e0 <Strptime_Strptime+0x70>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1374 <Strptime_Strptime+0x204>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     1371 <Strptime_Strptime+0x201>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1350 <Strptime_Strptime+0x1e0>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %rax,(%r14)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     13d4 <Strptime_Strptime+0x264>
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     13d1 <Strptime_Strptime+0x261>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    13b0 <Strptime_Strptime+0x240>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %rax,0x28(%r14)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1434 <Strptime_Strptime+0x2c4>
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     1431 <Strptime_Strptime+0x2c1>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1410 <Strptime_Strptime+0x2a0>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    0x28(%rsp),%rcx
jmp    1571 <Strptime_Strptime+0x401>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     17b6 <Strptime_Strptime+0x646>
mov    0x8(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     14a1 <Strptime_Strptime+0x331>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1480 <Strptime_Strptime+0x310>
add    %rbp,%rbx
jmp    17bb <Strptime_Strptime+0x64b>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     14e4 <Strptime_Strptime+0x374>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     14e1 <Strptime_Strptime+0x371>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    14c0 <Strptime_Strptime+0x350>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %rax,0x38(%r14)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1544 <Strptime_Strptime+0x3d4>
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     1541 <Strptime_Strptime+0x3d1>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1520 <Strptime_Strptime+0x3b0>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
add    $0xffffffffffffffff,%rax
mov    0x20(%rsp),%rcx
mov    %rax,(%rcx)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %r12d,%r12d
test   %al,%al
je     11e6 <Strptime_Strptime+0x76>
nopl   0x0(%rax)
movsbl %al,%edi
call   1070 <isspace@plt>
test   %eax,%eax
je     11e6 <Strptime_Strptime+0x76>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1590 <Strptime_Strptime+0x420>
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %r13d,%r13d
xor    %ebp,%ebp
test   %al,%al
je     15e4 <Strptime_Strptime+0x474>
nopl   0x0(%rax)
movsbl %al,%edi
call   1080 <isalpha@plt>
test   %eax,%eax
je     15e1 <Strptime_Strptime+0x471>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    15c0 <Strptime_Strptime+0x450>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0xaf2(%rip),%rdi
lea    0x30(%rsp),%rbp
mov    %rbp,%rsi
mov    $0x2,%edx
call   1030 <strncmp@plt>
mov    $0x0,%r12d
test   %eax,%eax
je     1639 <Strptime_Strptime+0x4c9>
lea    0xad2(%rip),%rdi
mov    %rbp,%rsi
mov    $0x2,%edx
call   1030 <strncmp@plt>
xor    %r12d,%r12d
test   %eax,%eax
setne  %r12b
mov    $0x1,%eax
mov    0x18(%rsp),%r13
cmove  %eax,%r13d
mov    (%r14),%rax
test   %rax,%rax
jle    1652 <Strptime_Strptime+0x4e2>
lea    0x0(,%r13,4),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %rcx,%rax
mov    %rax,(%r14)
mov    %r13,0x18(%rsp)
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1694 <Strptime_Strptime+0x524>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     1691 <Strptime_Strptime+0x521>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1670 <Strptime_Strptime+0x500>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    0x18(%rsp),%rcx
lea    0x0(,%rcx,4),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %rax,%rcx
mov    %rcx,(%r14)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %r12d,%r12d
test   %al,%al
je     11e6 <Strptime_Strptime+0x76>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsbl %al,%edi
call   1070 <isspace@plt>
test   %eax,%eax
je     11e6 <Strptime_Strptime+0x76>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    16f0 <Strptime_Strptime+0x580>
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     1744 <Strptime_Strptime+0x5d4>
nopl   0x0(%rax)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     1741 <Strptime_Strptime+0x5d1>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1720 <Strptime_Strptime+0x5b0>
add    %rbp,%rbx
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %rax,0x18(%r14)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
mov    (%rbx),%al
xor    %ebp,%ebp
test   %al,%al
je     17e3 <Strptime_Strptime+0x673>
mov    0x8(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %eax,%eax
je     17b1 <Strptime_Strptime+0x641>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x30(%rsp,%rbp,1)
movzbl 0x1(%rbx,%rbp,1),%eax
add    $0x1,%rbp
test   %al,%al
jne    1790 <Strptime_Strptime+0x620>
add    %rbp,%rbx
jmp    17e8 <Strptime_Strptime+0x678>
mov    0x8(%rsp),%r12
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
add    $0xfffffffffffff894,%rax
jmp    1836 <Strptime_Strptime+0x6c6>
mov    0x8(%rsp),%r12
mov    %ebp,%eax
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1849 <Strptime_Strptime+0x6d9>
mov    %rbp,%rdi
call   1090 <atoi@plt>
mov    %rax,(%r12)
mov    0x10(%rsp),%rcx
test   %ecx,%ecx
je     1820 <Strptime_Strptime+0x6b0>
imul   $0x64,%ecx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
jmp    1836 <Strptime_Strptime+0x6c6>
test   %rax,%rax
js     1842 <Strptime_Strptime+0x6d2>
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
cmp    $0x44,%rax
jg     183a <Strptime_Strptime+0x6ca>
add    $0x64,%rax
mov    %rax,(%r12)
xor    %r12d,%r12d
jmp    11e6 <Strptime_Strptime+0x76>
xor    %eax,%eax
jmp    1318 <Strptime_Strptime+0x1a8>
mov    %rbx,%rax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.tm = type { i64, i32, i64, i8*, i8*, i8*, i64, i8*, i64 }
@.str = [3 x i8] c"am\00"
@.str.1 = [3 x i8] c"pm\00"
define i8* @Strptime_Strptime(i8* %0, i8* %1, %struct.tm* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca %struct.tm*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca [256 x i8]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store %struct.tm* %2, %struct.tm** %6
%14 = load i8*, i8** %4
store i8* %14, i8** %7
%15 = load i8*, i8** %5
store i8* %15, i8** %8
%16 = load %struct.tm*, %struct.tm** %6
%17 = getelementptr inbounds %struct.tm, %struct.tm* %16, i32 0, i32 4
store i8* null, i8** %17
%18 = load %struct.tm*, %struct.tm** %6
%19 = getelementptr inbounds %struct.tm, %struct.tm* %18, i32 0, i32 5
store i8* null, i8** %19
%20 = load %struct.tm*, %struct.tm** %6
%21 = getelementptr inbounds %struct.tm, %struct.tm* %20, i32 0, i32 0
store i64 0, i64* %21
%22 = load %struct.tm*, %struct.tm** %6
%23 = getelementptr inbounds %struct.tm, %struct.tm* %22, i32 0, i32 1
store i32 1, i32* %23
%24 = load %struct.tm*, %struct.tm** %6
%25 = getelementptr inbounds %struct.tm, %struct.tm* %24, i32 0, i32 6
store i64 0, i64* %25
%26 = load %struct.tm*, %struct.tm** %6
%27 = getelementptr inbounds %struct.tm, %struct.tm* %26, i32 0, i32 2
store i64 0, i64* %27
%28 = load %struct.tm*, %struct.tm** %6
%29 = getelementptr inbounds %struct.tm, %struct.tm* %28, i32 0, i32 3
store i8* null, i8** %29
%30 = load %struct.tm*, %struct.tm** %6
%31 = getelementptr inbounds %struct.tm, %struct.tm* %30, i32 0, i32 7
store i8* null, i8** %31
%32 = load %struct.tm*, %struct.tm** %6
%33 = getelementptr inbounds %struct.tm, %struct.tm* %32, i32 0, i32 8
store i64 0, i64* %33
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %13
br label %34
34: ; preds = %642, %3
%35 = load i8*, i8** %8
%36 = load i8, i8* %35
%37 = icmp ne i8 %36, 0
br i1 %37, label %38, label %643
38: ; preds = %34
%39 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%40 = call i32 @memset(i8* %39, i32 0, i32 256)
%41 = load i8*, i8** %8
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = icmp eq i32 %43, 37
br i1 %44, label %45, label %623
45: ; preds = %38
%46 = load i8*, i8** %8
%47 = getelementptr inbounds i8, i8* %46, i32 1
store i8* %47, i8** %8
%48 = load i8*, i8** %8
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
switch i32 %50, label %605 [
i32 97, label %51
i32 65, label %52
i32 98, label %53
i32 66, label %54
i32 104, label %55
i32 99, label %56
i32 67, label %57
i32 100, label %92
i32 101, label %92
i32 68, label %129
i32 72, label %130
i32 73, label %167
i32 106, label %168
i32 109, label %204
i32 77, label %242
i32 110, label %278
i32 112, label %294
i32 114, label %347
i32 82, label %388
i32 83, label %389
i32 116, label %425
i32 84, label %441
i32 85, label %442
i32 119, label %443
i32 87, label %479
i32 120, label %480
i32 88, label %481
i32 121, label %482
i32 89, label %567
]
51: ; preds = %45
store i32 1, i32* %13
br label %620
52: ; preds = %45
store i32 1, i32* %13
br label %620
53: ; preds = %45
store i32 1, i32* %13
br label %620
54: ; preds = %45
store i32 1, i32* %13
br label %620
55: ; preds = %45
store i32 1, i32* %13
br label %620
56: ; preds = %45
store i32 1, i32* %13
br label %620
57: ; preds = %45
store i32 0, i32* %10
br label %58
58: ; preds = %78, %57
%59 = load i8*, i8** %7
%60 = load i8, i8* %59
%61 = icmp ne i8 %60, 0
br i1 %61, label %62, label %79
62: ; preds = %58
%63 = load i8*, i8** %7
%64 = load i8, i8* %63
%65 = call i32 @isdigit(i8 signext %64)
%66 = icmp ne i32 %65, 0
br i1 %66, label %67, label %77
67: ; preds = %62
%68 = load i8*, i8** %7
%69 = load i8, i8* %68
%70 = load i32, i32* %10
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %71
store i8 %69, i8* %72
%73 = load i32, i32* %10
%74 = add nsw i32 %73, 1
store i32 %74, i32* %10
%75 = load i8*, i8** %7
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %7
br label %78
77: ; preds = %62
br label %79
78: ; preds = %67
br label %58
79: ; preds = %77, %58
%80 = load i32, i32* %10
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %81
store i8 0, i8* %82
%83 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%84 = call i32 @strlen(i8* %83)
%85 = icmp sgt i32 %84, 0
br i1 %85, label %86, label %90
86: ; preds = %79
%87 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%88 = call i8* @atoi(i8* %87)
%89 = ptrtoint i8* %88 to i32
store i32 %89, i32* %11
br label %91
90: ; preds = %79
store i32 1, i32* %13
br label %91
91: ; preds = %90, %86
br label %620
92: ; preds = %45, %45
store i32 0, i32* %10
br label %93
93: ; preds = %113, %92
%94 = load i8*, i8** %7
%95 = load i8, i8* %94
%96 = icmp ne i8 %95, 0
br i1 %96, label %97, label %114
97: ; preds = %93
%98 = load i8*, i8** %7
%99 = load i8, i8* %98
%100 = call i32 @isdigit(i8 signext %99)
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %112
102: ; preds = %97
%103 = load i8*, i8** %7
%104 = load i8, i8* %103
%105 = load i32, i32* %10
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %106
store i8 %104, i8* %107
%108 = load i32, i32* %10
%109 = add nsw i32 %108, 1
store i32 %109, i32* %10
%110 = load i8*, i8** %7
%111 = getelementptr inbounds i8, i8* %110, i32 1
store i8* %111, i8** %7
br label %113
112: ; preds = %97
br label %114
113: ; preds = %102
br label %93
114: ; preds = %112, %93
%115 = load i32, i32* %10
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %116
store i8 0, i8* %117
%118 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%119 = call i32 @strlen(i8* %118)
%120 = icmp sgt i32 %119, 0
br i1 %120, label %121, label %127
121: ; preds = %114
%122 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%123 = call i8* @atoi(i8* %122)
%124 = ptrtoint i8* %123 to i32
%125 = load %struct.tm*, %struct.tm** %6
%126 = getelementptr inbounds %struct.tm, %struct.tm* %125, i32 0, i32 1
store i32 %124, i32* %126
br label %128
127: ; preds = %114
store i32 1, i32* %13
br label %128
128: ; preds = %127, %121
br label %620
129: ; preds = %45
store i32 1, i32* %13
br label %620
130: ; preds = %45
store i32 0, i32* %10
br label %131
131: ; preds = %151, %130
%132 = load i8*, i8** %7
%133 = load i8, i8* %132
%134 = icmp ne i8 %133, 0
br i1 %134, label %135, label %152
135: ; preds = %131
%136 = load i8*, i8** %7
%137 = load i8, i8* %136
%138 = call i32 @isdigit(i8 signext %137)
%139 = icmp ne i32 %138, 0
br i1 %139, label %140, label %150
140: ; preds = %135
%141 = load i8*, i8** %7
%142 = load i8, i8* %141
%143 = load i32, i32* %10
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %144
store i8 %142, i8* %145
%146 = load i32, i32* %10
%147 = add nsw i32 %146, 1
store i32 %147, i32* %10
%148 = load i8*, i8** %7
%149 = getelementptr inbounds i8, i8* %148, i32 1
store i8* %149, i8** %7
br label %151
150: ; preds = %135
br label %152
151: ; preds = %140
br label %131
152: ; preds = %150, %131
%153 = load i32, i32* %10
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %154
store i8 0, i8* %155
%156 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%157 = call i32 @strlen(i8* %156)
%158 = icmp sgt i32 %157, 0
br i1 %158, label %159, label %165
159: ; preds = %152
%160 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%161 = call i8* @atoi(i8* %160)
%162 = ptrtoint i8* %161 to i64
%163 = load %struct.tm*, %struct.tm** %6
%164 = getelementptr inbounds %struct.tm, %struct.tm* %163, i32 0, i32 0
store i64 %162, i64* %164
br label %166
165: ; preds = %152
store i32 1, i32* %13
br label %166
166: ; preds = %165, %159
br label %620
167: ; preds = %45
store i32 1, i32* %13
br label %620
168: ; preds = %45
store i32 0, i32* %10
br label %169
169: ; preds = %189, %168
%170 = load i8*, i8** %7
%171 = load i8, i8* %170
%172 = icmp ne i8 %171, 0
br i1 %172, label %173, label %190
173: ; preds = %169
%174 = load i8*, i8** %7
%175 = load i8, i8* %174
%176 = call i32 @isdigit(i8 signext %175)
%177 = icmp ne i32 %176, 0
br i1 %177, label %178, label %188
178: ; preds = %173
%179 = load i8*, i8** %7
%180 = load i8, i8* %179
%181 = load i32, i32* %10
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %182
store i8 %180, i8* %183
%184 = load i32, i32* %10
%185 = add nsw i32 %184, 1
store i32 %185, i32* %10
%186 = load i8*, i8** %7
%187 = getelementptr inbounds i8, i8* %186, i32 1
store i8* %187, i8** %7
br label %189
188: ; preds = %173
br label %190
189: ; preds = %178
br label %169
190: ; preds = %188, %169
%191 = load i32, i32* %10
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %192
store i8 0, i8* %193
%194 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%195 = call i32 @strlen(i8* %194)
%196 = icmp sgt i32 %195, 0
br i1 %196, label %197, label %202
197: ; preds = %190
%198 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%199 = call i8* @atoi(i8* %198)
%200 = load %struct.tm*, %struct.tm** %6
%201 = getelementptr inbounds %struct.tm, %struct.tm* %200, i32 0, i32 7
store i8* %199, i8** %201
br label %203
202: ; preds = %190
store i32 1, i32* %13
br label %203
203: ; preds = %202, %197
br label %620
204: ; preds = %45
store i32 0, i32* %10
br label %205
205: ; preds = %225, %204
%206 = load i8*, i8** %7
%207 = load i8, i8* %206
%208 = icmp ne i8 %207, 0
br i1 %208, label %209, label %226
209: ; preds = %205
%210 = load i8*, i8** %7
%211 = load i8, i8* %210
%212 = call i32 @isdigit(i8 signext %211)
%213 = icmp ne i32 %212, 0
br i1 %213, label %214, label %224
214: ; preds = %209
%215 = load i8*, i8** %7
%216 = load i8, i8* %215
%217 = load i32, i32* %10
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %218
store i8 %216, i8* %219
%220 = load i32, i32* %10
%221 = add nsw i32 %220, 1
store i32 %221, i32* %10
%222 = load i8*, i8** %7
%223 = getelementptr inbounds i8, i8* %222, i32 1
store i8* %223, i8** %7
br label %225
224: ; preds = %209
br label %226
225: ; preds = %214
br label %205
226: ; preds = %224, %205
%227 = load i32, i32* %10
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %228
store i8 0, i8* %229
%230 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%231 = call i32 @strlen(i8* %230)
%232 = icmp sgt i32 %231, 0
br i1 %232, label %233, label %240
233: ; preds = %226
%234 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%235 = call i8* @atoi(i8* %234)
%236 = getelementptr i8, i8* %235, i64 -1
%237 = ptrtoint i8* %236 to i64
%238 = load %struct.tm*, %struct.tm** %6
%239 = getelementptr inbounds %struct.tm, %struct.tm* %238, i32 0, i32 6
store i64 %237, i64* %239
br label %241
240: ; preds = %226
store i32 1, i32* %13
br label %241
241: ; preds = %240, %233
br label %620
242: ; preds = %45
store i32 0, i32* %10
br label %243
243: ; preds = %263, %242
%244 = load i8*, i8** %7
%245 = load i8, i8* %244
%246 = icmp ne i8 %245, 0
br i1 %246, label %247, label %264
247: ; preds = %243
%248 = load i8*, i8** %7
%249 = load i8, i8* %248
%250 = call i32 @isdigit(i8 signext %249)
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %262
252: ; preds = %247
%253 = load i8*, i8** %7
%254 = load i8, i8* %253
%255 = load i32, i32* %10
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %256
store i8 %254, i8* %257
%258 = load i32, i32* %10
%259 = add nsw i32 %258, 1
store i32 %259, i32* %10
%260 = load i8*, i8** %7
%261 = getelementptr inbounds i8, i8* %260, i32 1
store i8* %261, i8** %7
br label %263
262: ; preds = %247
br label %264
263: ; preds = %252
br label %243
264: ; preds = %262, %243
%265 = load i32, i32* %10
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %266
store i8 0, i8* %267
%268 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%269 = call i32 @strlen(i8* %268)
%270 = icmp sgt i32 %269, 0
br i1 %270, label %271, label %276
271: ; preds = %264
%272 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%273 = call i8* @atoi(i8* %272)
%274 = load %struct.tm*, %struct.tm** %6
%275 = getelementptr inbounds %struct.tm, %struct.tm* %274, i32 0, i32 5
store i8* %273, i8** %275
br label %277
276: ; preds = %264
store i32 1, i32* %13
br label %277
277: ; preds = %276, %271
br label %620
278: ; preds = %45
br label %279
279: ; preds = %292, %278
%280 = load i8*, i8** %7
%281 = load i8, i8* %280
%282 = icmp ne i8 %281, 0
br i1 %282, label %283, label %293
283: ; preds = %279
%284 = load i8*, i8** %7
%285 = load i8, i8* %284
%286 = call i32 @isspace(i8 signext %285)
%287 = icmp ne i32 %286, 0
br i1 %287, label %288, label %291
288: ; preds = %283
%289 = load i8*, i8** %7
%290 = getelementptr inbounds i8, i8* %289, i32 1
store i8* %290, i8** %7
br label %292
291: ; preds = %283
br label %293
292: ; preds = %288
br label %279
293: ; preds = %291, %279
br label %620
294: ; preds = %45
store i32 0, i32* %10
br label %295
295: ; preds = %315, %294
%296 = load i8*, i8** %7
%297 = load i8, i8* %296
%298 = icmp ne i8 %297, 0
br i1 %298, label %299, label %316
299: ; preds = %295
%300 = load i8*, i8** %7
%301 = load i8, i8* %300
%302 = call i32 @isalpha(i8 signext %301)
%303 = icmp ne i32 %302, 0
br i1 %303, label %304, label %314
304: ; preds = %299
%305 = load i8*, i8** %7
%306 = load i8, i8* %305
%307 = load i32, i32* %10
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %308
store i8 %306, i8* %309
%310 = load i32, i32* %10
%311 = add nsw i32 %310, 1
store i32 %311, i32* %10
%312 = load i8*, i8** %7
%313 = getelementptr inbounds i8, i8* %312, i32 1
store i8* %313, i8** %7
br label %315
314: ; preds = %299
br label %316
315: ; preds = %304
br label %295
316: ; preds = %314, %295
%317 = load i32, i32* %10
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %318
store i8 0, i8* %319
%320 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%321 = call i32 @strncmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %320, i32 2)
%322 = icmp eq i32 %321, 0
br i1 %322, label %323, label %324
323: ; preds = %316
store i32 0, i32* %12
br label %331
324: ; preds = %316
%325 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%326 = call i32 @strncmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %325, i32 2)
%327 = icmp eq i32 %326, 0
br i1 %327, label %328, label %329
328: ; preds = %324
store i32 1, i32* %12
br label %330
329: ; preds = %324
store i32 1, i32* %13
br label %330
330: ; preds = %329, %328
br label %331
331: ; preds = %330, %323
%332 = load %struct.tm*, %struct.tm** %6
%333 = getelementptr inbounds %struct.tm, %struct.tm* %332, i32 0, i32 0
%334 = load i64, i64* %333
%335 = icmp sgt i64 %334, 0
br i1 %335, label %336, label %346
336: ; preds = %331
%337 = load %struct.tm*, %struct.tm** %6
%338 = getelementptr inbounds %struct.tm, %struct.tm* %337, i32 0, i32 0
%339 = load i64, i64* %338
%340 = load i32, i32* %12
%341 = mul nsw i32 12, %340
%342 = sext i32 %341 to i64
%343 = add nsw i64 %339, %342
%344 = load %struct.tm*, %struct.tm** %6
%345 = getelementptr inbounds %struct.tm, %struct.tm* %344, i32 0, i32 0
store i64 %343, i64* %345
br label %346
346: ; preds = %336, %331
br label %620
347: ; preds = %45
store i32 0, i32* %10
br label %348
348: ; preds = %368, %347
%349 = load i8*, i8** %7
%350 = load i8, i8* %349
%351 = icmp ne i8 %350, 0
br i1 %351, label %352, label %369
352: ; preds = %348
%353 = load i8*, i8** %7
%354 = load i8, i8* %353
%355 = call i32 @isdigit(i8 signext %354)
%356 = icmp ne i32 %355, 0
br i1 %356, label %357, label %367
357: ; preds = %352
%358 = load i8*, i8** %7
%359 = load i8, i8* %358
%360 = load i32, i32* %10
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %361
store i8 %359, i8* %362
%363 = load i32, i32* %10
%364 = add nsw i32 %363, 1
store i32 %364, i32* %10
%365 = load i8*, i8** %7
%366 = getelementptr inbounds i8, i8* %365, i32 1
store i8* %366, i8** %7
br label %368
367: ; preds = %352
br label %369
368: ; preds = %357
br label %348
369: ; preds = %367, %348
%370 = load i32, i32* %10
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %371
store i8 0, i8* %372
%373 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%374 = call i32 @strlen(i8* %373)
%375 = icmp sgt i32 %374, 0
br i1 %375, label %376, label %386
376: ; preds = %369
%377 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%378 = call i8* @atoi(i8* %377)
%379 = load i32, i32* %12
%380 = mul nsw i32 12, %379
%381 = sext i32 %380 to i64
%382 = getelementptr i8, i8* %378, i64 %381
%383 = ptrtoint i8* %382 to i64
%384 = load %struct.tm*, %struct.tm** %6
%385 = getelementptr inbounds %struct.tm, %struct.tm* %384, i32 0, i32 0
store i64 %383, i64* %385
br label %387
386: ; preds = %369
store i32 1, i32* %13
br label %387
387: ; preds = %386, %376
br label %620
388: ; preds = %45
store i32 1, i32* %13
br label %620
389: ; preds = %45
store i32 0, i32* %10
br label %390
390: ; preds = %410, %389
%391 = load i8*, i8** %7
%392 = load i8, i8* %391
%393 = icmp ne i8 %392, 0
br i1 %393, label %394, label %411
394: ; preds = %390
%395 = load i8*, i8** %7
%396 = load i8, i8* %395
%397 = call i32 @isdigit(i8 signext %396)
%398 = icmp ne i32 %397, 0
br i1 %398, label %399, label %409
399: ; preds = %394
%400 = load i8*, i8** %7
%401 = load i8, i8* %400
%402 = load i32, i32* %10
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %403
store i8 %401, i8* %404
%405 = load i32, i32* %10
%406 = add nsw i32 %405, 1
store i32 %406, i32* %10
%407 = load i8*, i8** %7
%408 = getelementptr inbounds i8, i8* %407, i32 1
store i8* %408, i8** %7
br label %410
409: ; preds = %394
br label %411
410: ; preds = %399
br label %390
411: ; preds = %409, %390
%412 = load i32, i32* %10
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %413
store i8 0, i8* %414
%415 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%416 = call i32 @strlen(i8* %415)
%417 = icmp sgt i32 %416, 0
br i1 %417, label %418, label %423
418: ; preds = %411
%419 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%420 = call i8* @atoi(i8* %419)
%421 = load %struct.tm*, %struct.tm** %6
%422 = getelementptr inbounds %struct.tm, %struct.tm* %421, i32 0, i32 4
store i8* %420, i8** %422
br label %424
423: ; preds = %411
store i32 1, i32* %13
br label %424
424: ; preds = %423, %418
br label %620
425: ; preds = %45
br label %426
426: ; preds = %439, %425
%427 = load i8*, i8** %7
%428 = load i8, i8* %427
%429 = icmp ne i8 %428, 0
br i1 %429, label %430, label %440
430: ; preds = %426
%431 = load i8*, i8** %7
%432 = load i8, i8* %431
%433 = call i32 @isspace(i8 signext %432)
%434 = icmp ne i32 %433, 0
br i1 %434, label %435, label %438
435: ; preds = %430
%436 = load i8*, i8** %7
%437 = getelementptr inbounds i8, i8* %436, i32 1
store i8* %437, i8** %7
br label %439
438: ; preds = %430
br label %440
439: ; preds = %435
br label %426
440: ; preds = %438, %426
br label %620
441: ; preds = %45
store i32 1, i32* %13
br label %620
442: ; preds = %45
store i32 1, i32* %13
br label %620
443: ; preds = %45
store i32 0, i32* %10
br label %444
444: ; preds = %464, %443
%445 = load i8*, i8** %7
%446 = load i8, i8* %445
%447 = icmp ne i8 %446, 0
br i1 %447, label %448, label %465
448: ; preds = %444
%449 = load i8*, i8** %7
%450 = load i8, i8* %449
%451 = call i32 @isdigit(i8 signext %450)
%452 = icmp ne i32 %451, 0
br i1 %452, label %453, label %463
453: ; preds = %448
%454 = load i8*, i8** %7
%455 = load i8, i8* %454
%456 = load i32, i32* %10
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %457
store i8 %455, i8* %458
%459 = load i32, i32* %10
%460 = add nsw i32 %459, 1
store i32 %460, i32* %10
%461 = load i8*, i8** %7
%462 = getelementptr inbounds i8, i8* %461, i32 1
store i8* %462, i8** %7
br label %464
463: ; preds = %448
br label %465
464: ; preds = %453
br label %444
465: ; preds = %463, %444
%466 = load i32, i32* %10
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %467
store i8 0, i8* %468
%469 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%470 = call i32 @strlen(i8* %469)
%471 = icmp sgt i32 %470, 0
br i1 %471, label %472, label %477
472: ; preds = %465
%473 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%474 = call i8* @atoi(i8* %473)
%475 = load %struct.tm*, %struct.tm** %6
%476 = getelementptr inbounds %struct.tm, %struct.tm* %475, i32 0, i32 3
store i8* %474, i8** %476
br label %478
477: ; preds = %465
store i32 1, i32* %13
br label %478
478: ; preds = %477, %472
br label %620
479: ; preds = %45
store i32 1, i32* %13
br label %620
480: ; preds = %45
store i32 1, i32* %13
br label %620
481: ; preds = %45
store i32 1, i32* %13
br label %620
482: ; preds = %45
store i32 0, i32* %10
br label %483
483: ; preds = %503, %482
%484 = load i8*, i8** %7
%485 = load i8, i8* %484
%486 = icmp ne i8 %485, 0
br i1 %486, label %487, label %504
487: ; preds = %483
%488 = load i8*, i8** %7
%489 = load i8, i8* %488
%490 = call i32 @isdigit(i8 signext %489)
%491 = icmp ne i32 %490, 0
br i1 %491, label %492, label %502
492: ; preds = %487
%493 = load i8*, i8** %7
%494 = load i8, i8* %493
%495 = load i32, i32* %10
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %496
store i8 %494, i8* %497
%498 = load i32, i32* %10
%499 = add nsw i32 %498, 1
store i32 %499, i32* %10
%500 = load i8*, i8** %7
%501 = getelementptr inbounds i8, i8* %500, i32 1
store i8* %501, i8** %7
br label %503
502: ; preds = %487
br label %504
503: ; preds = %492
br label %483
504: ; preds = %502, %483
%505 = load i32, i32* %10
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %506
store i8 0, i8* %507
%508 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%509 = call i32 @strlen(i8* %508)
%510 = icmp sgt i32 %509, 0
br i1 %510, label %511, label %565
511: ; preds = %504
%512 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%513 = call i8* @atoi(i8* %512)
%514 = ptrtoint i8* %513 to i64
%515 = load %struct.tm*, %struct.tm** %6
%516 = getelementptr inbounds %struct.tm, %struct.tm* %515, i32 0, i32 2
store i64 %514, i64* %516
%517 = load i32, i32* %11
%518 = icmp eq i32 %517, 0
br i1 %518, label %519, label %554
519: ; preds = %511
%520 = load %struct.tm*, %struct.tm** %6
%521 = getelementptr inbounds %struct.tm, %struct.tm* %520, i32 0, i32 2
%522 = load i64, i64* %521
%523 = icmp sge i64 %522, 0
br i1 %523, label %524, label %536
524: ; preds = %519
%525 = load %struct.tm*, %struct.tm** %6
%526 = getelementptr inbounds %struct.tm, %struct.tm* %525, i32 0, i32 2
%527 = load i64, i64* %526
%528 = icmp sle i64 %527, 68
br i1 %528, label %529, label %536
529: ; preds = %524
%530 = load %struct.tm*, %struct.tm** %6
%531 = getelementptr inbounds %struct.tm, %struct.tm* %530, i32 0, i32 2
%532 = load i64, i64* %531
%533 = add nsw i64 %532, 100
%534 = load %struct.tm*, %struct.tm** %6
%535 = getelementptr inbounds %struct.tm, %struct.tm* %534, i32 0, i32 2
store i64 %533, i64* %535
br label %553
536: ; preds = %524, %519
%537 = load %struct.tm*, %struct.tm** %6
%538 = getelementptr inbounds %struct.tm, %struct.tm* %537, i32 0, i32 2
%539 = load i64, i64* %538
%540 = icmp sge i64 %539, 69
br i1 %540, label %541, label %552
541: ; preds = %536
%542 = load %struct.tm*, %struct.tm** %6
%543 = getelementptr inbounds %struct.tm, %struct.tm* %542, i32 0, i32 2
%544 = load i64, i64* %543
%545 = icmp sle i64 %544, 99
br i1 %545, label %546, label %552
546: ; preds = %541
%547 = load %struct.tm*, %struct.tm** %6
%548 = getelementptr inbounds %struct.tm, %struct.tm* %547, i32 0, i32 2
%549 = load i64, i64* %548
%550 = load %struct.tm*, %struct.tm** %6
%551 = getelementptr inbounds %struct.tm, %struct.tm* %550, i32 0, i32 2
store i64 %549, i64* %551
br label %552
552: ; preds = %546, %541, %536
br label %553
553: ; preds = %552, %529
br label %564
554: ; preds = %511
%555 = load %struct.tm*, %struct.tm** %6
%556 = getelementptr inbounds %struct.tm, %struct.tm* %555, i32 0, i32 2
%557 = load i64, i64* %556
%558 = load i32, i32* %11
%559 = mul nsw i32 %558, 100
%560 = sext i32 %559 to i64
%561 = add nsw i64 %557, %560
%562 = load %struct.tm*, %struct.tm** %6
%563 = getelementptr inbounds %struct.tm, %struct.tm* %562, i32 0, i32 2
store i64 %561, i64* %563
br label %564
564: ; preds = %554, %553
br label %566
565: ; preds = %504
store i32 1, i32* %13
br label %566
566: ; preds = %565, %564
br label %620
567: ; preds = %45
store i32 0, i32* %10
br label %568
568: ; preds = %588, %567
%569 = load i8*, i8** %7
%570 = load i8, i8* %569
%571 = icmp ne i8 %570, 0
br i1 %571, label %572, label %589
572: ; preds = %568
%573 = load i8*, i8** %7
%574 = load i8, i8* %573
%575 = call i32 @isdigit(i8 signext %574)
%576 = icmp ne i32 %575, 0
br i1 %576, label %577, label %587
577: ; preds = %572
%578 = load i8*, i8** %7
%579 = load i8, i8* %578
%580 = load i32, i32* %10
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %581
store i8 %579, i8* %582
%583 = load i32, i32* %10
%584 = add nsw i32 %583, 1
store i32 %584, i32* %10
%585 = load i8*, i8** %7
%586 = getelementptr inbounds i8, i8* %585, i32 1
store i8* %586, i8** %7
br label %588
587: ; preds = %572
br label %589
588: ; preds = %577
br label %568
589: ; preds = %587, %568
%590 = load i32, i32* %10
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 %591
store i8 0, i8* %592
%593 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%594 = call i32 @strlen(i8* %593)
%595 = icmp sgt i32 %594, 0
br i1 %595, label %596, label %603
596: ; preds = %589
%597 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%598 = call i8* @atoi(i8* %597)
%599 = getelementptr i8, i8* %598, i64 -1900
%600 = ptrtoint i8* %599 to i64
%601 = load %struct.tm*, %struct.tm** %6
%602 = getelementptr inbounds %struct.tm, %struct.tm* %601, i32 0, i32 2
store i64 %600, i64* %602
br label %604
603: ; preds = %589
store i32 1, i32* %13
br label %604
604: ; preds = %603, %596
br label %620
605: ; preds = %45
%606 = load i8*, i8** %7
%607 = load i8, i8* %606
%608 = sext i8 %607 to i32
%609 = load i8*, i8** %8
%610 = load i8, i8* %609
%611 = sext i8 %610 to i32
%612 = icmp eq i32 %608, %611
br i1 %612, label %613, label %618
613: ; preds = %605
%614 = load i8*, i8** %7
%615 = getelementptr inbounds i8, i8* %614, i32 1
store i8* %615, i8** %7
%616 = load i8*, i8** %8
%617 = getelementptr inbounds i8, i8* %616, i32 1
store i8* %617, i8** %8
br label %619
618: ; preds = %605
store i32 1, i32* %13
br label %619
619: ; preds = %618, %613
br label %620
620: ; preds = %619, %604, %566, %481, %480, %479, %478, %442, %441, %440, %424, %388, %387, %346, %293, %277, %241, %203, %167, %166, %129, %128, %91, %56, %55, %54, %53, %52, %51
%621 = load i8*, i8** %8
%622 = getelementptr inbounds i8, i8* %621, i32 1
store i8* %622, i8** %8
br label %638
623: ; preds = %38
%624 = load i8*, i8** %7
%625 = load i8, i8* %624
%626 = sext i8 %625 to i32
%627 = load i8*, i8** %8
%628 = load i8, i8* %627
%629 = sext i8 %628 to i32
%630 = icmp eq i32 %626, %629
br i1 %630, label %631, label %636
631: ; preds = %623
%632 = load i8*, i8** %7
%633 = getelementptr inbounds i8, i8* %632, i32 1
store i8* %633, i8** %7
%634 = load i8*, i8** %8
%635 = getelementptr inbounds i8, i8* %634, i32 1
store i8* %635, i8** %8
br label %637
636: ; preds = %623
store i32 1, i32* %13
br label %637
637: ; preds = %636, %631
br label %638
638: ; preds = %637, %620
%639 = load i32, i32* %13
%640 = icmp ne i32 %639, 0
br i1 %640, label %641, label %642
641: ; preds = %638
br label %643
642: ; preds = %638
br label %34
643: ; preds = %641, %34
%644 = load i8*, i8** %7
ret i8* %644
}

LLVM IR (-O2):
%struct.tm = type { i64, i32, i64, i8*, i8*, i8*, i64, i8*, i64 }
@.str = [3 x i8] c"am\00"
@.str.1 = [3 x i8] c"pm\00"
define i8* @Strptime_Strptime(i8* %0, i8* %1, %struct.tm* nocapture %2) {
%4 = alloca [256 x i8]
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%6 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 4
%7 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 5
%8 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 0
store i64 0, i64* %8
%9 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 1
%10 = bitcast i8** %6 to i8*
store i32 1, i32* %9
%11 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 6
%12 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 2
%13 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 3
%14 = getelementptr inbounds %struct.tm, %struct.tm* %2, i64 0, i32 7
%15 = bitcast i64* %12 to i8*
%16 = bitcast i64* %11 to i8*
br label %17
17: ; preds = %453, %3
%18 = phi i8* [ %0, %3 ], [ %454, %453 ]
%19 = phi i8* [ %1, %3 ], [ %459, %453 ]
%20 = phi i32 [ 0, %3 ], [ %456, %453 ]
%21 = phi i32 [ 0, %3 ], [ %457, %453 ]
%22 = load i8, i8* %19
%23 = icmp eq i8 %22, 0
br i1 %23, label %461, label %24
24: ; preds = %17
%25 = call i32 @memset(i8* %5, i32 0, i32 256)
%26 = load i8, i8* %19
%27 = icmp eq i8 %26, 37
br i1 %27, label %28, label %448
28: ; preds = %24
%29 = getelementptr inbounds i8, i8* %19, i64 1
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
switch i32 %31, label %442 [
i32 97, label %461
i32 65, label %461
i32 98, label %461
i32 66, label %461
i32 104, label %461
i32 99, label %461
i32 67, label %68
i32 100, label %99
i32 101, label %99
i32 68, label %461
i32 72, label %65
i32 73, label %461
i32 106, label %62
i32 109, label %59
i32 77, label %56
i32 110, label %53
i32 112, label %50
i32 114, label %47
i32 82, label %461
i32 83, label %44
i32 116, label %41
i32 84, label %461
i32 85, label %461
i32 119, label %38
i32 87, label %461
i32 120, label %461
i32 88, label %461
i32 121, label %35
i32 89, label %32
]
32: ; preds = %28
%33 = load i8, i8* %18
%34 = icmp eq i8 %33, 0
br i1 %34, label %431, label %414
35: ; preds = %28
%36 = load i8, i8* %18
%37 = icmp eq i8 %36, 0
br i1 %37, label %393, label %376
38: ; preds = %28
%39 = load i8, i8* %18
%40 = icmp eq i8 %39, 0
br i1 %40, label %367, label %350
41: ; preds = %28
%42 = load i8, i8* %18
%43 = icmp eq i8 %42, 0
br i1 %43, label %453, label %341
44: ; preds = %28
%45 = load i8, i8* %18
%46 = icmp eq i8 %45, 0
br i1 %46, label %332, label %315
47: ; preds = %28
%48 = load i8, i8* %18
%49 = icmp eq i8 %48, 0
br i1 %49, label %302, label %285
50: ; preds = %28
%51 = load i8, i8* %18
%52 = icmp eq i8 %51, 0
br i1 %52, label %263, label %246
53: ; preds = %28
%54 = load i8, i8* %18
%55 = icmp eq i8 %54, 0
br i1 %55, label %453, label %237
56: ; preds = %28
%57 = load i8, i8* %18
%58 = icmp eq i8 %57, 0
br i1 %58, label %228, label %211
59: ; preds = %28
%60 = load i8, i8* %18
%61 = icmp eq i8 %60, 0
br i1 %61, label %200, label %183
62: ; preds = %28
%63 = load i8, i8* %18
%64 = icmp eq i8 %63, 0
br i1 %64, label %174, label %157
65: ; preds = %28
%66 = load i8, i8* %18
%67 = icmp eq i8 %66, 0
br i1 %67, label %147, label %130
68: ; preds = %28
%69 = load i8, i8* %18
%70 = icmp eq i8 %69, 0
br i1 %70, label %88, label %71
71: ; preds = %68, %78
%72 = phi i64 [ %81, %78 ], [ 0, %68 ]
%73 = phi i8 [ %84, %78 ], [ %69, %68 ]
%74 = phi i32 [ %82, %78 ], [ 0, %68 ]
%75 = phi i8* [ %83, %78 ], [ %18, %68 ]
%76 = call i32 @isdigit(i8 signext %73)
%77 = icmp eq i32 %76, 0
br i1 %77, label %86, label %78
78: ; preds = %71
%79 = load i8, i8* %75
%80 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %72
store i8 %79, i8* %80
%81 = add nuw i64 %72, 1
%82 = add nuw nsw i32 %74, 1
%83 = getelementptr inbounds i8, i8* %75, i64 1
%84 = load i8, i8* %83
%85 = icmp eq i8 %84, 0
br i1 %85, label %88, label %71
86: ; preds = %71
%87 = trunc i64 %72 to i32
br label %88
88: ; preds = %78, %86, %68
%89 = phi i8* [ %18, %68 ], [ %75, %86 ], [ %83, %78 ]
%90 = phi i32 [ 0, %68 ], [ %87, %86 ], [ %82, %78 ]
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %91
store i8 0, i8* %92
%93 = call i32 @strlen(i8* %5)
%94 = icmp sgt i32 %93, 0
br i1 %94, label %95, label %461
95: ; preds = %88
%96 = call i8* @atoi(i8* %5)
%97 = ptrtoint i8* %96 to i64
%98 = trunc i64 %97 to i32
br label %453
99: ; preds = %28, %28
%100 = load i8, i8* %18
%101 = icmp eq i8 %100, 0
br i1 %101, label %119, label %102
102: ; preds = %99, %109
%103 = phi i64 [ %112, %109 ], [ 0, %99 ]
%104 = phi i8 [ %115, %109 ], [ %100, %99 ]
%105 = phi i32 [ %113, %109 ], [ 0, %99 ]
%106 = phi i8* [ %114, %109 ], [ %18, %99 ]
%107 = call i32 @isdigit(i8 signext %104)
%108 = icmp eq i32 %107, 0
br i1 %108, label %117, label %109
109: ; preds = %102
%110 = load i8, i8* %106
%111 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %103
store i8 %110, i8* %111
%112 = add nuw i64 %103, 1
%113 = add nuw nsw i32 %105, 1
%114 = getelementptr inbounds i8, i8* %106, i64 1
%115 = load i8, i8* %114
%116 = icmp eq i8 %115, 0
br i1 %116, label %119, label %102
117: ; preds = %102
%118 = trunc i64 %103 to i32
br label %119
119: ; preds = %109, %117, %99
%120 = phi i8* [ %18, %99 ], [ %106, %117 ], [ %114, %109 ]
%121 = phi i32 [ 0, %99 ], [ %118, %117 ], [ %113, %109 ]
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %122
store i8 0, i8* %123
%124 = call i32 @strlen(i8* %5)
%125 = icmp sgt i32 %124, 0
br i1 %125, label %126, label %461
126: ; preds = %119
%127 = call i8* @atoi(i8* %5)
%128 = ptrtoint i8* %127 to i64
%129 = trunc i64 %128 to i32
store i32 %129, i32* %9
br label %453
130: ; preds = %65, %137
%131 = phi i64 [ %140, %137 ], [ 0, %65 ]
%132 = phi i8 [ %143, %137 ], [ %66, %65 ]
%133 = phi i32 [ %141, %137 ], [ 0, %65 ]
%134 = phi i8* [ %142, %137 ], [ %18, %65 ]
%135 = call i32 @isdigit(i8 signext %132)
%136 = icmp eq i32 %135, 0
br i1 %136, label %145, label %137
137: ; preds = %130
%138 = load i8, i8* %134
%139 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %131
store i8 %138, i8* %139
%140 = add nuw i64 %131, 1
%141 = add nuw nsw i32 %133, 1
%142 = getelementptr inbounds i8, i8* %134, i64 1
%143 = load i8, i8* %142
%144 = icmp eq i8 %143, 0
br i1 %144, label %147, label %130
145: ; preds = %130
%146 = trunc i64 %131 to i32
br label %147
147: ; preds = %137, %145, %65
%148 = phi i8* [ %18, %65 ], [ %134, %145 ], [ %142, %137 ]
%149 = phi i32 [ 0, %65 ], [ %146, %145 ], [ %141, %137 ]
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %150
store i8 0, i8* %151
%152 = call i32 @strlen(i8* %5)
%153 = icmp sgt i32 %152, 0
br i1 %153, label %154, label %461
154: ; preds = %147
%155 = call i8* @atoi(i8* %5)
%156 = ptrtoint i8* %155 to i64
store i64 %156, i64* %8
br label %453
157: ; preds = %62, %164
%158 = phi i64 [ %167, %164 ], [ 0, %62 ]
%159 = phi i8 [ %170, %164 ], [ %63, %62 ]
%160 = phi i32 [ %168, %164 ], [ 0, %62 ]
%161 = phi i8* [ %169, %164 ], [ %18, %62 ]
%162 = call i32 @isdigit(i8 signext %159)
%163 = icmp eq i32 %162, 0
br i1 %163, label %172, label %164
164: ; preds = %157
%165 = load i8, i8* %161
%166 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %158
store i8 %165, i8* %166
%167 = add nuw i64 %158, 1
%168 = add nuw nsw i32 %160, 1
%169 = getelementptr inbounds i8, i8* %161, i64 1
%170 = load i8, i8* %169
%171 = icmp eq i8 %170, 0
br i1 %171, label %174, label %157
172: ; preds = %157
%173 = trunc i64 %158 to i32
br label %174
174: ; preds = %164, %172, %62
%175 = phi i8* [ %18, %62 ], [ %161, %172 ], [ %169, %164 ]
%176 = phi i32 [ 0, %62 ], [ %173, %172 ], [ %168, %164 ]
%177 = zext i32 %176 to i64
%178 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %177
store i8 0, i8* %178
%179 = call i32 @strlen(i8* %5)
%180 = icmp sgt i32 %179, 0
br i1 %180, label %181, label %461
181: ; preds = %174
%182 = call i8* @atoi(i8* %5)
store i8* %182, i8** %14
br label %453
183: ; preds = %59, %190
%184 = phi i64 [ %193, %190 ], [ 0, %59 ]
%185 = phi i8 [ %196, %190 ], [ %60, %59 ]
%186 = phi i32 [ %194, %190 ], [ 0, %59 ]
%187 = phi i8* [ %195, %190 ], [ %18, %59 ]
%188 = call i32 @isdigit(i8 signext %185)
%189 = icmp eq i32 %188, 0
br i1 %189, label %198, label %190
190: ; preds = %183
%191 = load i8, i8* %187
%192 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %184
store i8 %191, i8* %192
%193 = add nuw i64 %184, 1
%194 = add nuw nsw i32 %186, 1
%195 = getelementptr inbounds i8, i8* %187, i64 1
%196 = load i8, i8* %195
%197 = icmp eq i8 %196, 0
br i1 %197, label %200, label %183
198: ; preds = %183
%199 = trunc i64 %184 to i32
br label %200
200: ; preds = %190, %198, %59
%201 = phi i8* [ %18, %59 ], [ %187, %198 ], [ %195, %190 ]
%202 = phi i32 [ 0, %59 ], [ %199, %198 ], [ %194, %190 ]
%203 = zext i32 %202 to i64
%204 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %203
store i8 0, i8* %204
%205 = call i32 @strlen(i8* %5)
%206 = icmp sgt i32 %205, 0
br i1 %206, label %207, label %461
207: ; preds = %200
%208 = call i8* @atoi(i8* %5)
%209 = getelementptr i8, i8* %208, i64 -1
%210 = ptrtoint i8* %209 to i64
store i64 %210, i64* %11
br label %453
211: ; preds = %56, %218
%212 = phi i64 [ %221, %218 ], [ 0, %56 ]
%213 = phi i8 [ %224, %218 ], [ %57, %56 ]
%214 = phi i32 [ %222, %218 ], [ 0, %56 ]
%215 = phi i8* [ %223, %218 ], [ %18, %56 ]
%216 = call i32 @isdigit(i8 signext %213)
%217 = icmp eq i32 %216, 0
br i1 %217, label %226, label %218
218: ; preds = %211
%219 = load i8, i8* %215
%220 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %212
store i8 %219, i8* %220
%221 = add nuw i64 %212, 1
%222 = add nuw nsw i32 %214, 1
%223 = getelementptr inbounds i8, i8* %215, i64 1
%224 = load i8, i8* %223
%225 = icmp eq i8 %224, 0
br i1 %225, label %228, label %211
226: ; preds = %211
%227 = trunc i64 %212 to i32
br label %228
228: ; preds = %218, %226, %56
%229 = phi i8* [ %18, %56 ], [ %215, %226 ], [ %223, %218 ]
%230 = phi i32 [ 0, %56 ], [ %227, %226 ], [ %222, %218 ]
%231 = zext i32 %230 to i64
%232 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %231
store i8 0, i8* %232
%233 = call i32 @strlen(i8* %5)
%234 = icmp sgt i32 %233, 0
br i1 %234, label %235, label %461
235: ; preds = %228
%236 = call i8* @atoi(i8* %5)
store i8* %236, i8** %7
br label %453
237: ; preds = %53, %242
%238 = phi i8 [ %244, %242 ], [ %54, %53 ]
%239 = phi i8* [ %243, %242 ], [ %18, %53 ]
%240 = call i32 @isspace(i8 signext %238)
%241 = icmp eq i32 %240, 0
br i1 %241, label %453, label %242
242: ; preds = %237
%243 = getelementptr inbounds i8, i8* %239, i64 1
%244 = load i8, i8* %243
%245 = icmp eq i8 %244, 0
br i1 %245, label %453, label %237
246: ; preds = %50, %253
%247 = phi i64 [ %256, %253 ], [ 0, %50 ]
%248 = phi i8 [ %259, %253 ], [ %51, %50 ]
%249 = phi i32 [ %257, %253 ], [ 0, %50 ]
%250 = phi i8* [ %258, %253 ], [ %18, %50 ]
%251 = call i32 @isalpha(i8 signext %248)
%252 = icmp eq i32 %251, 0
br i1 %252, label %261, label %253
253: ; preds = %246
%254 = load i8, i8* %250
%255 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %247
store i8 %254, i8* %255
%256 = add nuw i64 %247, 1
%257 = add nuw nsw i32 %249, 1
%258 = getelementptr inbounds i8, i8* %250, i64 1
%259 = load i8, i8* %258
%260 = icmp eq i8 %259, 0
br i1 %260, label %263, label %246
261: ; preds = %246
%262 = trunc i64 %247 to i32
br label %263
263: ; preds = %253, %261, %50
%264 = phi i8* [ %18, %50 ], [ %250, %261 ], [ %258, %253 ]
%265 = phi i32 [ 0, %50 ], [ %262, %261 ], [ %257, %253 ]
%266 = zext i32 %265 to i64
%267 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %266
store i8 0, i8* %267
%268 = call i32 @strncmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %5, i32 2)
%269 = icmp eq i32 %268, 0
br i1 %269, label %276, label %270
270: ; preds = %263
%271 = call i32 @strncmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %5, i32 2)
%272 = icmp eq i32 %271, 0
%273 = select i1 %272, i32 1, i32 %21
%274 = xor i1 %272, true
%275 = zext i1 %274 to i32
br label %276
276: ; preds = %270, %263
%277 = phi i32 [ 0, %263 ], [ %273, %270 ]
%278 = phi i32 [ 0, %263 ], [ %275, %270 ]
%279 = load i64, i64* %8
%280 = icmp sgt i64 %279, 0
br i1 %280, label %281, label %453
281: ; preds = %276
%282 = mul nsw i32 %277, 12
%283 = zext i32 %282 to i64
%284 = add nuw nsw i64 %279, %283
store i64 %284, i64* %8
br label %453
285: ; preds = %47, %292
%286 = phi i64 [ %295, %292 ], [ 0, %47 ]
%287 = phi i8 [ %298, %292 ], [ %48, %47 ]
%288 = phi i32 [ %296, %292 ], [ 0, %47 ]
%289 = phi i8* [ %297, %292 ], [ %18, %47 ]
%290 = call i32 @isdigit(i8 signext %287)
%291 = icmp eq i32 %290, 0
br i1 %291, label %300, label %292
292: ; preds = %285
%293 = load i8, i8* %289
%294 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %286
store i8 %293, i8* %294
%295 = add nuw i64 %286, 1
%296 = add nuw nsw i32 %288, 1
%297 = getelementptr inbounds i8, i8* %289, i64 1
%298 = load i8, i8* %297
%299 = icmp eq i8 %298, 0
br i1 %299, label %302, label %285
300: ; preds = %285
%301 = trunc i64 %286 to i32
br label %302
302: ; preds = %292, %300, %47
%303 = phi i8* [ %18, %47 ], [ %289, %300 ], [ %297, %292 ]
%304 = phi i32 [ 0, %47 ], [ %301, %300 ], [ %296, %292 ]
%305 = zext i32 %304 to i64
%306 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %305
store i8 0, i8* %306
%307 = call i32 @strlen(i8* %5)
%308 = icmp sgt i32 %307, 0
br i1 %308, label %309, label %461
309: ; preds = %302
%310 = call i8* @atoi(i8* %5)
%311 = mul nsw i32 %21, 12
%312 = zext i32 %311 to i64
%313 = getelementptr i8, i8* %310, i64 %312
%314 = ptrtoint i8* %313 to i64
store i64 %314, i64* %8
br label %453
315: ; preds = %44, %322
%316 = phi i64 [ %325, %322 ], [ 0, %44 ]
%317 = phi i8 [ %328, %322 ], [ %45, %44 ]
%318 = phi i32 [ %326, %322 ], [ 0, %44 ]
%319 = phi i8* [ %327, %322 ], [ %18, %44 ]
%320 = call i32 @isdigit(i8 signext %317)
%321 = icmp eq i32 %320, 0
br i1 %321, label %330, label %322
322: ; preds = %315
%323 = load i8, i8* %319
%324 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %316
store i8 %323, i8* %324
%325 = add nuw i64 %316, 1
%326 = add nuw nsw i32 %318, 1
%327 = getelementptr inbounds i8, i8* %319, i64 1
%328 = load i8, i8* %327
%329 = icmp eq i8 %328, 0
br i1 %329, label %332, label %315
330: ; preds = %315
%331 = trunc i64 %316 to i32
br label %332
332: ; preds = %322, %330, %44
%333 = phi i8* [ %18, %44 ], [ %319, %330 ], [ %327, %322 ]
%334 = phi i32 [ 0, %44 ], [ %331, %330 ], [ %326, %322 ]
%335 = zext i32 %334 to i64
%336 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %335
store i8 0, i8* %336
%337 = call i32 @strlen(i8* %5)
%338 = icmp sgt i32 %337, 0
br i1 %338, label %339, label %461
339: ; preds = %332
%340 = call i8* @atoi(i8* %5)
store i8* %340, i8** %6
br label %453
341: ; preds = %41, %346
%342 = phi i8 [ %348, %346 ], [ %42, %41 ]
%343 = phi i8* [ %347, %346 ], [ %18, %41 ]
%344 = call i32 @isspace(i8 signext %342)
%345 = icmp eq i32 %344, 0
br i1 %345, label %453, label %346
346: ; preds = %341
%347 = getelementptr inbounds i8, i8* %343, i64 1
%348 = load i8, i8* %347
%349 = icmp eq i8 %348, 0
br i1 %349, label %453, label %341
350: ; preds = %38, %357
%351 = phi i64 [ %360, %357 ], [ 0, %38 ]
%352 = phi i8 [ %363, %357 ], [ %39, %38 ]
%353 = phi i32 [ %361, %357 ], [ 0, %38 ]
%354 = phi i8* [ %362, %357 ], [ %18, %38 ]
%355 = call i32 @isdigit(i8 signext %352)
%356 = icmp eq i32 %355, 0
br i1 %356, label %365, label %357
357: ; preds = %350
%358 = load i8, i8* %354
%359 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %351
store i8 %358, i8* %359
%360 = add nuw i64 %351, 1
%361 = add nuw nsw i32 %353, 1
%362 = getelementptr inbounds i8, i8* %354, i64 1
%363 = load i8, i8* %362
%364 = icmp eq i8 %363, 0
br i1 %364, label %367, label %350
365: ; preds = %350
%366 = trunc i64 %351 to i32
br label %367
367: ; preds = %357, %365, %38
%368 = phi i8* [ %18, %38 ], [ %354, %365 ], [ %362, %357 ]
%369 = phi i32 [ 0, %38 ], [ %366, %365 ], [ %361, %357 ]
%370 = zext i32 %369 to i64
%371 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %370
store i8 0, i8* %371
%372 = call i32 @strlen(i8* %5)
%373 = icmp sgt i32 %372, 0
br i1 %373, label %374, label %461
374: ; preds = %367
%375 = call i8* @atoi(i8* %5)
store i8* %375, i8** %13
br label %453
376: ; preds = %35, %383
%377 = phi i64 [ %386, %383 ], [ 0, %35 ]
%378 = phi i8 [ %389, %383 ], [ %36, %35 ]
%379 = phi i32 [ %387, %383 ], [ 0, %35 ]
%380 = phi i8* [ %388, %383 ], [ %18, %35 ]
%381 = call i32 @isdigit(i8 signext %378)
%382 = icmp eq i32 %381, 0
br i1 %382, label %391, label %383
383: ; preds = %376
%384 = load i8, i8* %380
%385 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %377
store i8 %384, i8* %385
%386 = add nuw i64 %377, 1
%387 = add nuw nsw i32 %379, 1
%388 = getelementptr inbounds i8, i8* %380, i64 1
%389 = load i8, i8* %388
%390 = icmp eq i8 %389, 0
br i1 %390, label %393, label %376
391: ; preds = %376
%392 = trunc i64 %377 to i32
br label %393
393: ; preds = %383, %391, %35
%394 = phi i8* [ %18, %35 ], [ %380, %391 ], [ %388, %383 ]
%395 = phi i32 [ 0, %35 ], [ %392, %391 ], [ %387, %383 ]
%396 = zext i32 %395 to i64
%397 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %396
store i8 0, i8* %397
%398 = call i32 @strlen(i8* %5)
%399 = icmp sgt i32 %398, 0
br i1 %399, label %400, label %461
400: ; preds = %393
%401 = call i8* @atoi(i8* %5)
%402 = ptrtoint i8* %401 to i64
store i64 %402, i64* %12
%403 = icmp eq i32 %20, 0
br i1 %403, label %404, label %410
404: ; preds = %400
%405 = icmp sgt i8* %401, inttoptr (i64 -1 to i8*)
%406 = icmp slt i8* %401, inttoptr (i64 69 to i8*)
%407 = and i1 %405, %406
br i1 %407, label %408, label %453
408: ; preds = %404
%409 = add nsw i64 %402, 100
store i64 %409, i64* %12
br label %453
410: ; preds = %400
%411 = mul nsw i32 %20, 100
%412 = sext i32 %411 to i64
%413 = add nsw i64 %402, %412
store i64 %413, i64* %12
br label %453
414: ; preds = %32, %421
%415 = phi i64 [ %424, %421 ], [ 0, %32 ]
%416 = phi i8 [ %427, %421 ], [ %33, %32 ]
%417 = phi i32 [ %425, %421 ], [ 0, %32 ]
%418 = phi i8* [ %426, %421 ], [ %18, %32 ]
%419 = call i32 @isdigit(i8 signext %416)
%420 = icmp eq i32 %419, 0
br i1 %420, label %429, label %421
421: ; preds = %414
%422 = load i8, i8* %418
%423 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %415
store i8 %422, i8* %423
%424 = add nuw i64 %415, 1
%425 = add nuw nsw i32 %417, 1
%426 = getelementptr inbounds i8, i8* %418, i64 1
%427 = load i8, i8* %426
%428 = icmp eq i8 %427, 0
br i1 %428, label %431, label %414
429: ; preds = %414
%430 = trunc i64 %415 to i32
br label %431
431: ; preds = %421, %429, %32
%432 = phi i8* [ %18, %32 ], [ %418, %429 ], [ %426, %421 ]
%433 = phi i32 [ 0, %32 ], [ %430, %429 ], [ %425, %421 ]
%434 = zext i32 %433 to i64
%435 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %434
store i8 0, i8* %435
%436 = call i32 @strlen(i8* %5)
%437 = icmp sgt i32 %436, 0
br i1 %437, label %438, label %461
438: ; preds = %431
%439 = call i8* @atoi(i8* %5)
%440 = getelementptr i8, i8* %439, i64 -1900
%441 = ptrtoint i8* %440 to i64
store i64 %441, i64* %12
br label %453
442: ; preds = %28
%443 = load i8, i8* %18
%444 = icmp eq i8 %443, %30
br i1 %444, label %445, label %461
445: ; preds = %442
%446 = getelementptr inbounds i8, i8* %18, i64 1
%447 = getelementptr inbounds i8, i8* %19, i64 2
br label %453
448: ; preds = %24
%449 = load i8, i8* %18
%450 = icmp eq i8 %449, %26
br i1 %450, label %451, label %461
451: ; preds = %448
%452 = getelementptr inbounds i8, i8* %18, i64 1
br label %453
453: ; preds = %346, %341, %242, %237, %41, %53, %95, %126, %154, %181, %207, %235, %281, %276, %309, %339, %374, %410, %408, %438, %445, %404, %451
%454 = phi i8* [ %452, %451 ], [ %446, %445 ], [ %432, %438 ], [ %394, %408 ], [ %394, %410 ], [ %368, %374 ], [ %333, %339 ], [ %303, %309 ], [ %264, %281 ], [ %264, %276 ], [ %229, %235 ], [ %201, %207 ], [ %175, %181 ], [ %148, %154 ], [ %120, %126 ], [ %89, %95 ], [ %394, %404 ], [ %18, %53 ], [ %18, %41 ], [ %243, %242 ], [ %239, %237 ], [ %347, %346 ], [ %343, %341 ]
%455 = phi i8* [ %19, %451 ], [ %447, %445 ], [ %29, %438 ], [ %29, %408 ], [ %29, %410 ], [ %29, %374 ], [ %29, %339 ], [ %29, %309 ], [ %29, %281 ], [ %29, %276 ], [ %29, %235 ], [ %29, %207 ], [ %29, %181 ], [ %29, %154 ], [ %29, %126 ], [ %29, %95 ], [ %29, %404 ], [ %29, %53 ], [ %29, %41 ], [ %29, %237 ], [ %29, %242 ], [ %29, %341 ], [ %29, %346 ]
%456 = phi i32 [ %20, %451 ], [ %20, %445 ], [ %20, %438 ], [ 0, %408 ], [ %20, %410 ], [ %20, %374 ], [ %20, %339 ], [ %20, %309 ], [ %20, %281 ], [ %20, %276 ], [ %20, %235 ], [ %20, %207 ], [ %20, %181 ], [ %20, %154 ], [ %20, %126 ], [ %98, %95 ], [ 0, %404 ], [ %20, %53 ], [ %20, %41 ], [ %20, %237 ], [ %20, %242 ], [ %20, %341 ], [ %20, %346 ]
%457 = phi i32 [ %21, %451 ], [ %21, %445 ], [ %21, %438 ], [ %21, %408 ], [ %21, %410 ], [ %21, %374 ], [ %21, %339 ], [ %21, %309 ], [ %277, %281 ], [ %277, %276 ], [ %21, %235 ], [ %21, %207 ], [ %21, %181 ], [ %21, %154 ], [ %21, %126 ], [ %21, %95 ], [ %21, %404 ], [ %21, %53 ], [ %21, %41 ], [ %21, %237 ], [ %21, %242 ], [ %21, %341 ], [ %21, %346 ]
%458 = phi i32 [ 0, %451 ], [ 0, %445 ], [ 0, %438 ], [ 0, %408 ], [ 0, %410 ], [ 0, %374 ], [ 0, %339 ], [ 0, %309 ], [ %278, %281 ], [ %278, %276 ], [ 0, %235 ], [ 0, %207 ], [ 0, %181 ], [ 0, %154 ], [ 0, %126 ], [ 0, %95 ], [ 0, %404 ], [ 0, %53 ], [ 0, %41 ], [ 0, %237 ], [ 0, %242 ], [ 0, %341 ], [ 0, %346 ]
%459 = getelementptr inbounds i8, i8* %455, i64 1
%460 = icmp eq i32 %458, 0
br i1 %460, label %17, label %461
461: ; preds = %442, %431, %393, %367, %332, %302, %228, %200, %174, %147, %119, %88, %28, %28, %28, %28, %28, %28, %28, %28, %28, %28, %28, %28, %28, %28, %448, %453, %17
%462 = phi i8* [ %454, %453 ], [ %18, %17 ], [ %18, %448 ], [ %18, %442 ], [ %432, %431 ], [ %394, %393 ], [ %18, %28 ], [ %18, %28 ], [ %18, %28 ], [ %368, %367 ], [ %18, %28 ], [ %18, %28 ], [ %333, %332 ], [ %18, %28 ], [ %303, %302 ], [ %229, %228 ], [ %201, %200 ], [ %175, %174 ], [ %18, %28 ], [ %148, %147 ], [ %18, %28 ], [ %120, %119 ], [ %89, %88 ], [ %18, %28 ], [ %18, %28 ], [ %18, %28 ], [ %18, %28 ], [ %18, %28 ], [ %18, %28 ]
ret i8* %462
}