int main(int argc, char **argv) {
  int i, j, k;
  char indexString[3];
  char srcIpAddrInDottedDecimalString[16];
  char srcIpAddrOctetString[4][5];
  int srcIpAddrOctetNum[4];
  long int srcIpAddr;
  char dstIpAddrInDottedDecimalString[16];
  char dstIpAddrOctetString[4][5];
  int dstIpAddrOctetNum[4];
  long int dstIpAddr;
  char srcPortString[6];
  int srcPortNum;
  char dstPortString[6];
  int dstPortNum;
  char testChar;
  if (argc < 2 || argc > 6 || argv[1][0] == '?' || argv[1][0] == 'h') {
    printf("  This C program generates the following eSeries LM-10 shell "
           "command:\n");
    printf(
        "   camClassFind "
        "0x80000000,0xii0600ss,0xssssssdd,0x800000dd,0xddddpppp,0xPPPP8000\n");
    printf("   ii =\n");
    printf("    <classifierEngineIndex> from the \"showPolicy <policyId>\" "
           "eSeries SRP shell command output;\n");
    printf("     <policyId> is the last hex number on the \"Policy "
           "<inPolicy>...\" line from the \"showPolicyIds\" eSeries SRP shell "
           "command output;\n");
    printf("     <inPolicy> is the last word from the \"ip policy input "
           "<inPolicy>\" line in the \"show configuration interface "
           "<interFaceTyp> <interfaceNumber>\"\n");
    printf("      sSeries CLI command output.\n");
    printf("   ssssssss = <SA> =\n");
    printf("    source ip address (default is 1.1.1.1 = 0x01010101)\n");
    printf("   dddddddd = <DA> =\n");
    printf("    destination ip address (default is 2.2.2.2 = 0x02020202)\n");
    printf("   pppp = <SP> =\n");
    printf("    source port (default is 2000 = 0x07D0 = ephemeral)\n");
    printf("   ssss = <DP> =\n");
    printf("    destination port (default is 25 = 0x19 = SMTP)\n");
    printf("  Refer to 2011-0111-0591, KA<tbd> and/or the "
           "\"http://www-int.juniper.net/customerservice/jtac/techdocs/ERX/"
           "docs/junose_shell_command_reference.pdf\" doc\n");
    printf("  Written by Jonathan Natale for Juniper Networks on 19-Feb-11.\n");
    printf("Usage:\n");
    printf(
        " %s <classifierEngineIndex (hex, without 0x)> [<SA (dotted decimal)> "
        "[<DA (dotted decimal)> [<SP (decimal)> [<DP (decimal)>]]]]\n",
        argv[0]);
    return (1);
  }
  for (i = 0; i < 4; i++) {
    srcIpAddrOctetNum[i] = 1;
  }
  for (i = 0; i < 4; i++) {
    dstIpAddrOctetNum[i] = 2;
  }
  srcPortNum = 2000;
  dstPortNum = 25;
  if (strlen(argv[1]) > 2) {
    printf("Sorry, %s is too long (should be less then 3 chars).\n", argv[i]);
    printf("Please try again.  Exiting ...\n");
    return (2);
  }
  for (i = 0; i < strlen(argv[1]); i++) {
    if (!isxdigit(argv[1][i])) {
      printf("Sorry, %c is not a valid hex digit.\n", argv[1][i]);
      printf("Please try again.  Exiting ...\n");
      return (3);
    }
  }
  strcpy(indexString, argv[1]);
  switch (argc) {
  case 6: {
    for (i = 0; i < strlen(argv[5]); i++) {
      if (!isdigit(argv[5][i])) {
        printf("Sorry, %c is not a valid dec digit.\n", argv[5][i]);
        printf("Please try again.  Exiting ...\n");
        return (4);
      }
    }
    dstPortNum = atoi(argv[5]);
  }
  case 5: {
    for (i = 0; i < strlen(argv[4]); i++) {
      if (!isdigit(argv[4][i])) {
        printf("Sorry, %s is not a valid dec digit.\n", argv[4][i]);
        printf("Please try again.  Exiting ...\n");
        return (5);
      }
    }
    srcPortNum = atoi(argv[4]);
  }
  case 4: {
    strcpy(dstIpAddrInDottedDecimalString, argv[3]);
    if ((strlen(dstIpAddrInDottedDecimalString) > 15) ||
        (strlen(dstIpAddrInDottedDecimalString) < 7)) {
      printf("Sorry, %s is not a valid IP address in hex.\n",
             dstIpAddrInDottedDecimalString);
      printf("It has the wrong number of digits");
      printf(" (%d, expected between 7 and 15).\n",
             strlen(dstIpAddrInDottedDecimalString));
      printf("Please try again.  Exiting ...\n");
      return (6);
    }
    for (i = 0; i < strlen(dstIpAddrInDottedDecimalString); i++) {
      if (!isdigit(dstIpAddrInDottedDecimalString[i]) &&
          dstIpAddrInDottedDecimalString[i] != '.') {
        printf("Sorry, %s is not a valid IP address in dotted decimal.\n",
               dstIpAddrInDottedDecimalString);
        printf("       ");
        for (j = 0; j < i; j++) {
          printf(" ");
        }
        printf("^\n");
        printf("Please try again.  Exiting ...\n");
        return (7);
      }
    }
    i = 0;
    k = 0;
    for (j = 0; j <= strlen(dstIpAddrInDottedDecimalString); j++) {
      if (dstIpAddrInDottedDecimalString[j] != '.' &&
          dstIpAddrInDottedDecimalString[j] != '\0') {
        dstIpAddrOctetString[i][k++] = dstIpAddrInDottedDecimalString[j];
      } else {
        if (k < 1 || k > 3) {
          printf("Sorry, octet #%d has the wrong number of digits (%d).\n",
                 i + 1, k);
          printf("Please try again.  Exiting ...\n");
          return (8);
        }
        dstIpAddrOctetString[i][k] = '\0';
        dstIpAddrOctetNum[i] = atoi(dstIpAddrOctetString[i]);
        if (dstIpAddrOctetNum[i] < 0 || dstIpAddrOctetNum[i] > 255) {
          printf("Sorry, %s contains an invalid IP octet (%d).\n",
                 dstIpAddrInDottedDecimalString, dstIpAddrOctetNum[i]);
          printf("It must be >= 0 and <= 255.\n");
          printf("Please try again.  Exiting ...\n");
          return (9);
        }
        i++;
        k = 0;
      }
    }
    if (i != 4) {
      printf("Sorry, wrong number of octets (%d, expected 4)\n", i);
      printf("Please try again.  Exiting ...\n");
      return (10);
    }
    dstIpAddr = 0;
    for (i = 0; i < 3; i++) {
      dstIpAddr = dstIpAddrOctetNum[i] | dstIpAddr;
      dstIpAddr = dstIpAddr << 8;
    }
    dstIpAddr = dstIpAddrOctetNum[i] | dstIpAddr;
  }
  case 3: {
    strcpy(srcIpAddrInDottedDecimalString, argv[2]);
    if ((strlen(srcIpAddrInDottedDecimalString) > 15) ||
        (strlen(srcIpAddrInDottedDecimalString) < 7)) {
      printf("Sorry, %s is not a valid IP address in hex.\n",
             srcIpAddrInDottedDecimalString);
      printf("It has the wrong number of digits");
      printf(" (%d, expected between 7 and 15).\n",
             strlen(srcIpAddrInDottedDecimalString));
      printf("Please try again.  Exiting ...\n");
      return (11);
    }
    for (i = 0; i < strlen(srcIpAddrInDottedDecimalString); i++) {
      if (!isdigit(srcIpAddrInDottedDecimalString[i]) &&
          srcIpAddrInDottedDecimalString[i] != '.') {
        printf("Sorry, %s is not a valid IP address in dotted decimal.\n",
               srcIpAddrInDottedDecimalString);
        printf("       ");
        for (j = 0; j < i; j++) {
          printf(" ");
        }
        printf("^\n");
        printf("Please try again.  Exiting ...\n");
        return (12);
      }
    }
    i = 0;
    k = 0;
    for (j = 0; j <= strlen(srcIpAddrInDottedDecimalString); j++) {
      if (srcIpAddrInDottedDecimalString[j] != '.' &&
          srcIpAddrInDottedDecimalString[j] != '\0') {
        srcIpAddrOctetString[i][k++] = srcIpAddrInDottedDecimalString[j];
      } else {
        if (k < 1 || k > 3) {
          printf("Sorry, octet #%d has the wrong number of digits (%d).\n",
                 i + 1, k);
          printf("Please try again.  Exiting ...\n");
          return (13);
        }
        srcIpAddrOctetString[i][k] = '\0';
        srcIpAddrOctetNum[i] = atoi(srcIpAddrOctetString[i]);
        if (srcIpAddrOctetNum[i] < 0 || srcIpAddrOctetNum[i] > 255) {
          printf("Sorry, %s contains an invalid IP octet (%d).\n",
                 srcIpAddrInDottedDecimalString, srcIpAddrOctetNum[i]);
          printf("It must be >= 0 and <= 255.\n");
          printf("Please try again.  Exiting ...\n");
          return (14);
        }
        i++;
        k = 0;
      }
    }
    if (i != 4) {
      printf("Sorry, wrong number of octets (%d, expected 4)\n", i);
      printf("Please try again.  Exiting ...\n");
      return (15);
    }
    srcIpAddr = 0;
    for (i = 0; i < 3; i++) {
      srcIpAddr = srcIpAddrOctetNum[i] | srcIpAddr;
      srcIpAddr = srcIpAddr << 8;
    }
    srcIpAddr = srcIpAddrOctetNum[i] | srcIpAddr;
  }
  }
  printf("camClassFind "
         "0x80000000,0x%s0600%02.2X,0x%02.2X%02.2X%02.2X%02.2X,0x800000%02.2X,"
         "0x%02.2X%02.2X%04.4X,0x%X8000\n",
         indexString, srcIpAddrOctetNum[0], srcIpAddrOctetNum[1],
         srcIpAddrOctetNum[2], srcIpAddrOctetNum[3], dstIpAddrOctetNum[0],
         dstIpAddrOctetNum[1], dstIpAddrOctetNum[2], dstIpAddrOctetNum[3],
         srcPortNum, dstPortNum);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x158,%rsp
movl   $0x0,-0x1c(%rbp)
mov    %edi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
cmpl   $0x2,-0x20(%rbp)
jl     11ba <main+0x5a>
cmpl   $0x6,-0x20(%rbp)
jg     11ba <main+0x5a>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
je     11ba <main+0x5a>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movsbl (%rax),%eax
cmp    $0x68,%eax
jne    12d7 <main+0x177>
lea    0xe4f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xe88(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xecd(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xec8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xf1a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xf92(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1018(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x102d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1035(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1060(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1068(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1098(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x109c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x10c6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x10ca(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x10f0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x117c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x11af(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%rsi
lea    0x11a2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    1302 <main+0x1a2>
movslq -0x2c(%rbp),%rax
movl   $0x1,-0x80(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12de <main+0x17e>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    1330 <main+0x1d0>
movslq -0x2c(%rbp),%rax
movl   $0x2,-0xd0(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1309 <main+0x1a9>
movl   $0x7d0,-0xe4(%rbp)
movl   $0x19,-0xf0(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rdi
call   1050 <strlen@plt>
cmp    $0x2,%rax
jbe    138f <main+0x22f>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x1179(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x11a1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x2,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x100(%rbp),%rax
cmp    %rcx,%rax
jae    142a <main+0x2ca>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <isxdigit@plt>
cmp    $0x0,%eax
jne    1417 <main+0x2b7>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0x1147(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1119(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x3,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
jmp    141c <main+0x2bc>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1396 <main+0x236>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rsi
lea    -0x37(%rbp),%rdi
call   1040 <strcpy@plt>
mov    -0x20(%rbp),%eax
add    $0xfffffffd,%eax
mov    %eax,%ecx
mov    %rcx,-0x108(%rbp)
sub    $0x3,%eax
ja     1d43 <main+0xbe3>
mov    -0x108(%rbp),%rax
lea    0xb9f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x110(%rbp),%rax
cmp    %rcx,%rax
jae    1505 <main+0x3a5>
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
jne    14f2 <main+0x392>
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0x1091(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x103e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x4,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
jmp    14f7 <main+0x397>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1471 <main+0x311>
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rdi
mov    $0x0,%al
call   1070 <atoi@plt>
mov    %eax,-0xf0(%rbp)
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x118(%rbp),%rax
cmp    %rcx,%rax
jae    15b5 <main+0x455>
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
jne    15a2 <main+0x442>
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0x1006(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xf8e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x5,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
jmp    15a7 <main+0x447>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1521 <main+0x3c1>
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rdi
mov    $0x0,%al
call   1070 <atoi@plt>
mov    %eax,-0xe4(%rbp)
lea    -0xa0(%rbp),%rdi
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rsi
call   1040 <strcpy@plt>
lea    -0xa0(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0xf,%rax
ja     160a <main+0x4aa>
lea    -0xa0(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x7,%rax
jae    1664 <main+0x504>
lea    -0xa0(%rbp),%rsi
lea    0xf94(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xfb3(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0xa0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rsi
lea    0xfb8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xecc(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x6,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
mov    %rax,-0x120(%rbp)
lea    -0xa0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x120(%rbp),%rax
cmp    %rcx,%rax
jae    1751 <main+0x5f1>
movslq -0x2c(%rbp),%rax
movsbl -0xa0(%rbp,%rax,1),%edi
ff
call   1030 <isdigit@plt>
cmp    $0x0,%eax
jne    173e <main+0x5de>
movslq -0x2c(%rbp),%rax
movsbl -0xa0(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
je     173e <main+0x5de>
lea    -0xa0(%rbp),%rsi
lea    0xf4c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xf76(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1716 <main+0x5b6>
lea    0xf5b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16ee <main+0x58e>
lea    0xf41(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xdf2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x7,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
jmp    1743 <main+0x5e3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    166b <main+0x50b>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
mov    %rax,-0x128(%rbp)
lea    -0xa0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x128(%rbp),%rax
cmp    %rcx,%rax
ja     1904 <main+0x7a4>
movslq -0x30(%rbp),%rax
movsbl -0xa0(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
je     17ed <main+0x68d>
movslq -0x30(%rbp),%rax
movsbl -0xa0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     17ed <main+0x68d>
movslq -0x30(%rbp),%rax
mov    -0xa0(%rbp,%rax,1),%dl
movslq -0x2c(%rbp),%rcx
lea    -0xc0(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    18f1 <main+0x791>
cmpl   $0x1,-0x34(%rbp)
jl     1801 <main+0x6a1>
cmpl   $0x3,-0x34(%rbp)
jle    1832 <main+0x6d2>
mov    -0x2c(%rbp),%esi
add    $0x1,%esi
mov    -0x34(%rbp),%edx
lea    0xe50(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xcfe(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x8,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movslq -0x2c(%rbp),%rcx
lea    -0xc0(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movslq -0x2c(%rbp),%rax
lea    -0xc0(%rbp),%rdi
imul   $0x5,%rax,%rax
add    %rax,%rdi
mov    $0x0,%al
call   1070 <atoi@plt>
mov    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0xd0(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
cmpl   $0x0,-0xd0(%rbp,%rax,4)
jl     1899 <main+0x739>
movslq -0x2c(%rbp),%rax
cmpl   $0xff,-0xd0(%rbp,%rax,4)
jle    18e1 <main+0x781>
lea    -0xa0(%rbp),%rsi
movslq -0x2c(%rbp),%rax
mov    -0xd0(%rbp,%rax,4),%edx
lea    0xde6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xe06(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xc4f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x9,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    18f6 <main+0x796>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1766 <main+0x606>
cmpl   $0x4,-0x2c(%rbp)
je     1939 <main+0x7d9>
mov    -0x2c(%rbp),%esi
lea    0xdcb(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xbf7(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xa,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movq   $0x0,-0xd8(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    198f <main+0x82f>
movslq -0x2c(%rbp),%rax
movslq -0xd0(%rbp,%rax,4),%rax
ff
or     -0xd8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    194b <main+0x7eb>
movslq -0x2c(%rbp),%rax
movslq -0xd0(%rbp,%rax,4),%rax
ff
or     -0xd8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
lea    -0x50(%rbp),%rdi
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rsi
call   1040 <strcpy@plt>
lea    -0x50(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0xf,%rax
ja     19e0 <main+0x880>
lea    -0x50(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x7,%rax
jae    1a34 <main+0x8d4>
lea    -0x50(%rbp),%rsi
lea    0xbc1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xbe0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0x50(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rsi
lea    0xbe8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xafc(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xb,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
mov    %rax,-0x130(%rbp)
lea    -0x50(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x130(%rbp),%rax
cmp    %rcx,%rax
jae    1b15 <main+0x9b5>
movslq -0x2c(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
jne    1b02 <main+0x9a2>
movslq -0x2c(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x2e,%eax
je     1b02 <main+0x9a2>
lea    -0x50(%rbp),%rsi
lea    0xb88(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xbb2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1ada <main+0x97a>
lea    0xb97(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ab2 <main+0x952>
lea    0xb7d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xa2e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xc,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
jmp    1b07 <main+0x9a7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a3b <main+0x8db>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
mov    %rax,-0x138(%rbp)
lea    -0x50(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x138(%rbp),%rax
cmp    %rcx,%rax
ja     1ca4 <main+0xb44>
movslq -0x30(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x2e,%eax
je     1ba2 <main+0xa42>
movslq -0x30(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     1ba2 <main+0xa42>
movslq -0x30(%rbp),%rax
mov    -0x50(%rbp,%rax,1),%dl
movslq -0x2c(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1c91 <main+0xb31>
cmpl   $0x1,-0x34(%rbp)
jl     1bb6 <main+0xa56>
cmpl   $0x3,-0x34(%rbp)
jle    1be7 <main+0xa87>
mov    -0x2c(%rbp),%esi
add    $0x1,%esi
mov    -0x34(%rbp),%edx
lea    0xa9b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x949(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xd,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movslq -0x2c(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movslq -0x2c(%rbp),%rax
lea    -0x70(%rbp),%rdi
imul   $0x5,%rax,%rax
add    %rax,%rdi
mov    $0x0,%al
call   1070 <atoi@plt>
mov    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
cmpl   $0x0,-0x80(%rbp,%rax,4)
jl     1c3f <main+0xadf>
movslq -0x2c(%rbp),%rax
cmpl   $0xff,-0x80(%rbp,%rax,4)
jle    1c81 <main+0xb21>
lea    -0x50(%rbp),%rsi
movslq -0x2c(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%edx
lea    0xa46(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xa66(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x8af(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xe,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    1c96 <main+0xb36>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b2a <main+0x9ca>
cmpl   $0x4,-0x2c(%rbp)
je     1cd9 <main+0xb79>
mov    -0x2c(%rbp),%esi
lea    0xa2b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x857(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xf,-0x1c(%rbp)
jmp    1dad <main+0xc4d>
movq   $0x0,-0x88(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1d2c <main+0xbcc>
movslq -0x2c(%rbp),%rax
movslq -0x80(%rbp,%rax,4),%rax
or     -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x88(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ceb <main+0xb8b>
movslq -0x2c(%rbp),%rax
movslq -0x80(%rbp,%rax,4),%rax
or     -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
lea    -0x37(%rbp),%rsi
mov    -0x80(%rbp),%edx
mov    -0x7c(%rbp),%ecx
mov    -0x78(%rbp),%r8d
mov    -0x74(%rbp),%r9d
mov    -0xd0(%rbp),%r15d
mov    -0xcc(%rbp),%r14d
mov    -0xc8(%rbp),%ebx
mov    -0xc4(%rbp),%r11d
mov    -0xe4(%rbp),%r10d
mov    -0xf0(%rbp),%eax
lea    0x98f(%rip),%rdi
mov    %r15d,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11d,0x18(%rsp)
mov    %r10d,0x20(%rsp)
mov    %eax,0x28(%rsp)
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x158,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rsi,%r13
mov    %edi,%r12d
lea    -0x7(%r12),%eax
cmp    $0xfffffffb,%eax
jb     11a7 <main+0x37>
mov    0x8(%r13),%r14
movsbl (%r14),%ebx
cmp    $0x3f,%ebx
je     11a7 <main+0x37>
cmp    $0x68,%bl
jne    12aa <main+0x13a>
lea    0x119c(%rip),%rdi
call   1050 <puts@plt>
lea    0x11d6(%rip),%rdi
call   1050 <puts@plt>
lea    0x121c(%rip),%rdi
call   1050 <puts@plt>
lea    0x1218(%rip),%rdi
call   1050 <puts@plt>
lea    0x126b(%rip),%rdi
call   1050 <puts@plt>
lea    0x12e4(%rip),%rdi
call   1050 <puts@plt>
lea    0x136b(%rip),%rdi
call   1050 <puts@plt>
lea    0x1381(%rip),%rdi
call   1050 <puts@plt>
lea    0x138a(%rip),%rdi
call   1050 <puts@plt>
lea    0x13b6(%rip),%rdi
call   1050 <puts@plt>
lea    0x13bf(%rip),%rdi
call   1050 <puts@plt>
lea    0x13f0(%rip),%rdi
call   1050 <puts@plt>
lea    0x13f5(%rip),%rdi
call   1050 <puts@plt>
lea    0x1420(%rip),%rdi
call   1050 <puts@plt>
lea    0x1425(%rip),%rdi
call   1050 <puts@plt>
lea    0x144c(%rip),%rdi
call   1050 <puts@plt>
lea    0x14d9(%rip),%rdi
call   1050 <puts@plt>
lea    0x150d(%rip),%rdi
call   1050 <puts@plt>
mov    0x0(%r13),%rsi
lea    0xda6(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0x1,%ebx
mov    %ebx,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movaps 0xd4f(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xd53(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
mov    %r14,%rdi
call   1060 <strlen@plt>
cmp    $0x2,%rax
jbe    12f5 <main+0x185>
mov    0x20(%r13),%rsi
lea    0xdd6(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x1042(%rip),%rdi
call   1050 <puts@plt>
mov    $0x2,%ebx
jmp    1296 <main+0x126>
mov    %rax,%r15
test   %rax,%rax
je     134f <main+0x1df>
mov    %ebx,%edi
call   1090 <isxdigit@plt>
test   %eax,%eax
je     1329 <main+0x1b9>
mov    $0x1,%ebp
nopl   (%rax)
cmp    %rbp,%r15
je     134f <main+0x1df>
movsbl (%r14,%rbp,1),%ebx
mov    %ebx,%edi
call   1090 <isxdigit@plt>
add    $0x1,%rbp
test   %eax,%eax
jne    1310 <main+0x1a0>
lea    0xdb7(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xfeb(%rip),%rdi
call   1050 <puts@plt>
mov    $0x3,%ebx
jmp    1296 <main+0x126>
lea    0x5(%rsp),%rdi
mov    %r14,%rsi
call   1040 <strcpy@plt>
mov    $0x19,%r14d
mov    $0x7d0,%eax
add    $0xfffffffd,%r12d
cmp    $0x3,%r12d
ja     1404 <main+0x294>
lea    0xca4(%rip),%rdx
movslq (%rdx,%r12,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    %rax,0x8(%rsp)
mov    0x10(%r13),%rsi
lea    0x20(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strcpy@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
lea    -0x10(%rax),%rcx
cmp    $0xfffffffffffffff7,%rcx
jae    15cf <main+0x45f>
lea    0xd9e(%rip),%rdi
lea    0x20(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xdb5(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
lea    0xdc1(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xf36(%rip),%rdi
call   1050 <puts@plt>
mov    $0xb,%ebx
jmp    1296 <main+0x126>
mov    $0x7d0,%eax
mov    %rax,0x8(%rsp)
mov    $0x19,%r13d
mov    $0x1,%r9d
mov    $0x2,%ebp
mov    $0x2,%r14d
mov    $0x2,%r11d
mov    $0x2,%r10d
mov    $0x1,%r8d
mov    $0x1,%ecx
mov    $0x1,%edx
lea    0xe55(%rip),%rdi
xor    %ebx,%ebx
lea    0x5(%rsp),%rsi
xor    %eax,%eax
push   %r13
push   0x10(%rsp)
push   %rbp
push   %r14
push   %r11
push   %r10
call   1070 <printf@plt>
add    $0x30,%rsp
jmp    1296 <main+0x126>
mov    0x28(%r13),%rbx
mov    %rbx,%rdi
call   1060 <strlen@plt>
test   %rax,%rax
je     1498 <main+0x328>
xor    %ecx,%ecx
movsbl (%rbx,%rcx,1),%esi
lea    -0x30(%rsi),%edx
cmp    $0xa,%edx
jae    16fc <main+0x58c>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    147f <main+0x30f>
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <atoi@plt>
mov    %eax,%r14d
mov    0x20(%r13),%rbx
mov    %rbx,%rdi
call   1060 <strlen@plt>
test   %rax,%rax
je     14d1 <main+0x361>
xor    %ecx,%ecx
movsbl (%rbx,%rcx,1),%esi
lea    -0x30(%rsi),%edx
cmp    $0xa,%edx
jae    1648 <main+0x4d8>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14b8 <main+0x348>
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <atoi@plt>
mov    %rax,0x8(%rsp)
mov    0x18(%r13),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strcpy@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
lea    -0x10(%rax),%rcx
cmp    $0xfffffffffffffff7,%rcx
jae    1556 <main+0x3e6>
lea    0xc4c(%rip),%rdi
lea    0x10(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xc63(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
lea    0xc6f(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xde4(%rip),%rdi
call   1050 <puts@plt>
mov    $0x6,%ebx
jmp    1296 <main+0x126>
xor    %ebx,%ebx
jmp    1567 <main+0x3f7>
add    $0x1,%rbx
cmp    %rbx,%rax
je     166c <main+0x4fc>
movsbl 0x10(%rsp,%rbx,1),%ecx
lea    -0x30(%rcx),%edx
cmp    $0xa,%edx
jb     155a <main+0x3ea>
cmp    $0x2e,%cl
je     155a <main+0x3ea>
lea    0xc48(%rip),%rdi
lea    0x10(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xc6d(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
test   %ebx,%ebx
je     15ad <main+0x43d>
mov    $0x20,%edi
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    159e <main+0x42e>
lea    0xd75(%rip),%rdi
call   1050 <puts@plt>
lea    0xd6b(%rip),%rdi
call   1050 <puts@plt>
mov    $0x7,%ebx
jmp    1296 <main+0x126>
xor    %ebx,%ebx
jmp    15e0 <main+0x470>
add    $0x1,%rbx
cmp    %rbx,%rax
je     1720 <main+0x5b0>
movsbl 0x20(%rsp,%rbx,1),%ecx
lea    -0x30(%rcx),%edx
cmp    $0xa,%edx
jb     15d3 <main+0x463>
cmp    $0x2e,%cl
je     15d3 <main+0x463>
lea    0xbcf(%rip),%rdi
lea    0x20(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xbf4(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
test   %ebx,%ebx
je     1626 <main+0x4b6>
mov    $0x20,%edi
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1617 <main+0x4a7>
lea    0xcfc(%rip),%rdi
call   1050 <puts@plt>
lea    0xcf2(%rip),%rdi
call   1050 <puts@plt>
mov    $0xc,%ebx
jmp    1296 <main+0x126>
lea    0xae2(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xcce(%rip),%rdi
call   1050 <puts@plt>
mov    $0x5,%ebx
jmp    1296 <main+0x126>
mov    %r14,0x58(%rsp)
mov    $0xffffffffffffffff,%r14
lea    0x10(%rsp),%r12
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    16af <main+0x53f>
movslq %ebp,%rcx
movslq %ebx,%rdx
add    $0x1,%ebx
lea    (%rcx,%rcx,4),%rcx
add    %rsp,%rcx
add    $0x60,%rcx
mov    %al,(%rdx,%rcx,1)
mov    %r12,%rdi
call   1060 <strlen@plt>
add    $0x1,%r14
cmp    %r14,%rax
jbe    17c0 <main+0x650>
movzbl 0x11(%rsp,%r14,1),%eax
test   %al,%al
je     16bd <main+0x54d>
cmp    $0x2e,%al
jne    1683 <main+0x513>
lea    -0x4(%rbx),%eax
cmp    $0xfffffffc,%eax
jbe    17f9 <main+0x689>
movslq %ebp,%r15
mov    %ebx,%eax
lea    (%r15,%r15,4),%rcx
lea    (%rsp,%rcx,1),%rdi
add    $0x60,%rdi
movb   $0x0,(%rax,%rdi,1)
xor    %eax,%eax
call   1080 <atoi@plt>
mov    %eax,0x30(%rsp,%r15,4)
cmp    $0x100,%eax
jae    1824 <main+0x6b4>
add    $0x1,%ebp
xor    %ebx,%ebx
jmp    169a <main+0x52a>
lea    0xa09(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xc1a(%rip),%rdi
call   1050 <puts@plt>
mov    $0x4,%ebx
jmp    1296 <main+0x126>
mov    %r14,%r13
mov    $0xffffffffffffffff,%rbx
lea    0x20(%rsp),%r12
xor    %r14d,%r14d
xor    %r15d,%r15d
jmp    1767 <main+0x5f7>
movslq %r14d,%rcx
movslq %r15d,%rdx
add    $0x1,%r15d
lea    (%rcx,%rcx,4),%rcx
add    %rsp,%rcx
add    $0x80,%rcx
mov    %al,(%rdx,%rcx,1)
mov    %r12,%rdi
call   1060 <strlen@plt>
add    $0x1,%rbx
cmp    %rbx,%rax
jbe    185b <main+0x6eb>
movzbl 0x21(%rsp,%rbx,1),%eax
test   %al,%al
je     1774 <main+0x604>
cmp    $0x2e,%al
jne    1737 <main+0x5c7>
lea    -0x4(%r15),%eax
cmp    $0xfffffffc,%eax
jbe    188f <main+0x71f>
movslq %r14d,%rbp
mov    %r15d,%eax
lea    0x0(,%rbp,4),%rcx
add    %rbp,%rcx
lea    (%rsp,%rcx,1),%rdi
add    $0x80,%rdi
movb   $0x0,(%rax,%rdi,1)
xor    %eax,%eax
call   1080 <atoi@plt>
mov    %eax,0x40(%rsp,%rbp,4)
cmp    $0x100,%eax
jae    18bd <main+0x74d>
add    $0x1,%r14d
xor    %r15d,%r15d
jmp    1752 <main+0x5e2>
cmp    $0x4,%ebp
mov    0x58(%rsp),%r14
mov    0x8(%rsp),%rax
je     1385 <main+0x215>
lea    0xa93(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xb41(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%ebx
jmp    1296 <main+0x126>
add    $0x1,%ebp
lea    0xa05(%rip),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xb16(%rip),%rdi
call   1050 <puts@plt>
mov    $0x8,%ebx
jmp    1296 <main+0x126>
lea    0xa14(%rip),%rdi
lea    0x10(%rsp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xacd(%rip),%rdi
call   1050 <puts@plt>
lea    0xadf(%rip),%rdi
call   1050 <puts@plt>
mov    $0x9,%ebx
jmp    1296 <main+0x126>
cmp    $0x4,%r14d
jne    18f4 <main+0x784>
mov    0x40(%rsp),%edx
mov    0x44(%rsp),%ecx
mov    0x48(%rsp),%r8d
mov    0x4c(%rsp),%r9d
mov    0x30(%rsp),%r10d
mov    0x34(%rsp),%r11d
mov    0x38(%rsp),%r14d
mov    0x3c(%rsp),%ebp
jmp    1441 <main+0x2d1>
add    $0x1,%r14d
lea    0x96e(%rip),%rdi
mov    %r14d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xa7d(%rip),%rdi
call   1050 <puts@plt>
mov    $0xd,%ebx
jmp    1296 <main+0x126>
lea    0x97b(%rip),%rdi
lea    0x20(%rsp),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xa34(%rip),%rdi
call   1050 <puts@plt>
lea    0xa46(%rip),%rdi
call   1050 <puts@plt>
mov    $0xe,%ebx
jmp    1296 <main+0x126>
lea    0x972(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xa1f(%rip),%rdi
call   1050 <puts@plt>
mov    $0xf,%ebx
jmp    1296 <main+0x126>

LLVM IR (-O0):
@.str = [71 x i8] c" This C program generates the following eSeries LM-10 shell command:\0A\00"
@.str.1 = [83 x i8] c" camClassFind 0x80000000,0xii0600ss,0xssssssdd,0x800000dd,0xddddpppp,0xPPPP8000\0A\00"
@.str.2 = [9 x i8] c" ii =\0A\00"
@.str.3 = [96 x i8] c" <classifierEngineIndex> from the \22showPolicy <policyId>\22 eSeries SRP shell command output;\0A\00"
@.str.4 = [134 x i8] c" <policyId> is the last hex number on the \22Policy <inPolicy>...\22 line from the \22showPolicyIds\22 eSeries SRP shell command output;\0A\00"
@.str.5 = [148 x i8] c" <inPolicy> is the last word from the \22ip policy input <inPolicy>\22 line in the \22show configuration interface <interFaceTyp> <interfaceNumber>\22\0A\00"
@.str.6 = [35 x i8] c" sSeries CLI command output.\0A\00"
@.str.7 = [22 x i8] c" ssssssss = <SA> =\0A\00"
@.str.8 = [57 x i8] c" source ip address (default is 1.1.1.1 = 0x01010101)\0A\00"
@.str.9 = [22 x i8] c" dddddddd = <DA> =\0A\00"
@.str.10 = [62 x i8] c" destination ip address (default is 2.2.2.2 = 0x02020202)\0A\00"
@.str.11 = [18 x i8] c" pppp = <SP> =\0A\00"
@.str.12 = [56 x i8] c" source port (default is 2000 = 0x07D0 = ephemeral)\0A\00"
@.str.13 = [18 x i8] c" ssss = <DP> =\0A\00"
@.str.14 = [52 x i8] c" destination port (default is 25 = 0x19 = SMTP)\0A\00"
@.str.15 = [154 x i8] c" Refer to 2011-0111-0591, KA<tbd> and/or the \22http://www-int.juniper.net/customerservice/jtac/techdocs/ERX/docs/junose_shell_command_reference.pdf\22 doc\0A\00"
@.str.16 = [65 x i8] c" Written by Jonathan Natale for Juniper Networks on 19-Feb-11.\0A\00"
@.str.17 = [8 x i8] c"Usage:\0A\00"
@.str.18 = [129 x i8] c" %s <classifierEngineIndex (hex, without 0x)> [<SA (dotted decimal)> [<DA (dotted decimal)> [<SP (decimal)> [<DP (decimal)>]]]]\0A\00"
@.str.19 = [54 x i8] c"Sorry, %s is too long (should be less then 3 chars).\0A\00"
@.str.20 = [32 x i8] c"Please try again. Exiting ...\0A\00"
@.str.21 = [37 x i8] c"Sorry, %c is not a valid hex digit.\0A\00"
@.str.22 = [37 x i8] c"Sorry, %c is not a valid dec digit.\0A\00"
@.str.23 = [37 x i8] c"Sorry, %s is not a valid dec digit.\0A\00"
@.str.24 = [45 x i8] c"Sorry, %s is not a valid IP address in hex.\0A\00"
@.str.25 = [34 x i8] c"It has the wrong number of digits\00"
@.str.26 = [35 x i8] c" (%d, expected between 7 and 15).\0A\00"
@.str.27 = [56 x i8] c"Sorry, %s is not a valid IP address in dotted decimal.\0A\00"
@.str.28 = [8 x i8] c" \00"
@.str.29 = [2 x i8] c" \00"
@.str.30 = [3 x i8] c"^\0A\00"
@.str.31 = [55 x i8] c"Sorry, octet #%d has the wrong number of digits (%d).\0A\00"
@.str.32 = [46 x i8] c"Sorry, %s contains an invalid IP octet (%d).\0A\00"
@.str.33 = [29 x i8] c"It must be >= 0 and <= 255.\0A\00"
@.str.34 = [48 x i8] c"Sorry, wrong number of octets (%d, expected 4)\0A\00"
@.str.35 = [112 x i8] c"camClassFind 0x80000000,0x%s0600%02.2X,0x%02.2X%02.2X%02.2X%02.2X,0x800000%02.2X,0x%02.2X%02.2X%04.4X,0x%X8000\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [3 x i8]
%10 = alloca [16 x i8]
%11 = alloca [4 x [5 x i8]]
%12 = alloca [4 x i32]
%13 = alloca i64
%14 = alloca [16 x i8]
%15 = alloca [4 x [5 x i8]]
%16 = alloca [4 x i32]
%17 = alloca i64
%18 = alloca [6 x i8]
%19 = alloca i32
%20 = alloca [6 x i8]
%21 = alloca i32
%22 = alloca i8
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%23 = load i32, i32* %4
%24 = icmp slt i32 %23, 2
br i1 %24, label %44, label %25
25: ; preds = %2
%26 = load i32, i32* %4
%27 = icmp sgt i32 %26, 6
br i1 %27, label %44, label %28
28: ; preds = %25
%29 = load i8**, i8*** %5
%30 = getelementptr inbounds i8*, i8** %29, i64 1
%31 = load i8*, i8** %30
%32 = getelementptr inbounds i8, i8* %31, i64 0
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 63
br i1 %35, label %44, label %36
36: ; preds = %28
%37 = load i8**, i8*** %5
%38 = getelementptr inbounds i8*, i8** %37, i64 1
%39 = load i8*, i8** %38
%40 = getelementptr inbounds i8, i8* %39, i64 0
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = icmp eq i32 %42, 104
br i1 %43, label %44, label %67
44: ; preds = %36, %28, %25, %2
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str, i64 0, i64 0))
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.1, i64 0, i64 0))
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str.3, i64 0, i64 0))
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([134 x i8], [134 x i8]* @.str.4, i64 0, i64 0))
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([148 x i8], [148 x i8]* @.str.5, i64 0, i64 0))
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.6, i64 0, i64 0))
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0))
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.8, i64 0, i64 0))
%54 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.9, i64 0, i64 0))
%55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.10, i64 0, i64 0))
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.11, i64 0, i64 0))
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.12, i64 0, i64 0))
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0))
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.14, i64 0, i64 0))
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([154 x i8], [154 x i8]* @.str.15, i64 0, i64 0))
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.16, i64 0, i64 0))
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i64 0, i64 0))
%63 = load i8**, i8*** %5
%64 = getelementptr inbounds i8*, i8** %63, i64 0
%65 = load i8*, i8** %64
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([129 x i8], [129 x i8]* @.str.18, i64 0, i64 0), i8* %65)
store i32 1, i32* %3
br label %610
67: ; preds = %36
store i32 0, i32* %6
br label %68
68: ; preds = %75, %67
%69 = load i32, i32* %6
%70 = icmp slt i32 %69, 4
br i1 %70, label %71, label %78
71: ; preds = %68
%72 = load i32, i32* %6
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %73
store i32 1, i32* %74
br label %75
75: ; preds = %71
%76 = load i32, i32* %6
%77 = add nsw i32 %76, 1
store i32 %77, i32* %6
br label %68
78: ; preds = %68
store i32 0, i32* %6
br label %79
79: ; preds = %86, %78
%80 = load i32, i32* %6
%81 = icmp slt i32 %80, 4
br i1 %81, label %82, label %89
82: ; preds = %79
%83 = load i32, i32* %6
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %84
store i32 2, i32* %85
br label %86
86: ; preds = %82
%87 = load i32, i32* %6
%88 = add nsw i32 %87, 1
store i32 %88, i32* %6
br label %79
89: ; preds = %79
store i32 2000, i32* %19
store i32 25, i32* %21
%90 = load i8**, i8*** %5
%91 = getelementptr inbounds i8*, i8** %90, i64 1
%92 = load i8*, i8** %91
%93 = call i64 @strlen(i8* %92)
%94 = icmp ugt i64 %93, 2
br i1 %94, label %95, label %103
95: ; preds = %89
%96 = load i8**, i8*** %5
%97 = load i32, i32* %6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i8*, i8** %96, i64 %98
%100 = load i8*, i8** %99
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.19, i64 0, i64 0), i8* %100)
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 2, i32* %3
br label %610
103: ; preds = %89
store i32 0, i32* %6
br label %104
104: ; preds = %135, %103
%105 = load i32, i32* %6
%106 = sext i32 %105 to i64
%107 = load i8**, i8*** %5
%108 = getelementptr inbounds i8*, i8** %107, i64 1
%109 = load i8*, i8** %108
%110 = call i64 @strlen(i8* %109)
%111 = icmp ult i64 %106, %110
br i1 %111, label %112, label %138
112: ; preds = %104
%113 = load i8**, i8*** %5
%114 = getelementptr inbounds i8*, i8** %113, i64 1
%115 = load i8*, i8** %114
%116 = load i32, i32* %6
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %115, i64 %117
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = call i32 @isxdigit(i32 %120)
%122 = icmp ne i32 %121, 0
br i1 %122, label %134, label %123
123: ; preds = %112
%124 = load i8**, i8*** %5
%125 = getelementptr inbounds i8*, i8** %124, i64 1
%126 = load i8*, i8** %125
%127 = load i32, i32* %6
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
%130 = load i8, i8* %129
%131 = sext i8 %130 to i32
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.21, i64 0, i64 0), i32 %131)
%133 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 3, i32* %3
br label %610
134: ; preds = %112
br label %135
135: ; preds = %134
%136 = load i32, i32* %6
%137 = add nsw i32 %136, 1
store i32 %137, i32* %6
br label %104
138: ; preds = %104
%139 = getelementptr inbounds [3 x i8], [3 x i8]* %9, i64 0, i64 0
%140 = load i8**, i8*** %5
%141 = getelementptr inbounds i8*, i8** %140, i64 1
%142 = load i8*, i8** %141
%143 = call i8* @strcpy(i8* %139, i8* %142)
%144 = load i32, i32* %4
switch i32 %144, label %589 [
i32 6, label %145
i32 5, label %185
i32 4, label %225
i32 3, label %407
]
145: ; preds = %138
store i32 0, i32* %6
br label %146
146: ; preds = %177, %145
%147 = load i32, i32* %6
%148 = sext i32 %147 to i64
%149 = load i8**, i8*** %5
%150 = getelementptr inbounds i8*, i8** %149, i64 5
%151 = load i8*, i8** %150
%152 = call i64 @strlen(i8* %151)
%153 = icmp ult i64 %148, %152
br i1 %153, label %154, label %180
154: ; preds = %146
%155 = load i8**, i8*** %5
%156 = getelementptr inbounds i8*, i8** %155, i64 5
%157 = load i8*, i8** %156
%158 = load i32, i32* %6
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i8, i8* %157, i64 %159
%161 = load i8, i8* %160
%162 = sext i8 %161 to i32
%163 = call i32 @isdigit(i32 %162)
%164 = icmp ne i32 %163, 0
br i1 %164, label %176, label %165
165: ; preds = %154
%166 = load i8**, i8*** %5
%167 = getelementptr inbounds i8*, i8** %166, i64 5
%168 = load i8*, i8** %167
%169 = load i32, i32* %6
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i8, i8* %168, i64 %170
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.22, i64 0, i64 0), i32 %173)
%175 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 4, i32* %3
br label %610
176: ; preds = %154
br label %177
177: ; preds = %176
%178 = load i32, i32* %6
%179 = add nsw i32 %178, 1
store i32 %179, i32* %6
br label %146
180: ; preds = %146
%181 = load i8**, i8*** %5
%182 = getelementptr inbounds i8*, i8** %181, i64 5
%183 = load i8*, i8** %182
%184 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %183)
store i32 %184, i32* %21
br label %185
185: ; preds = %138, %180
store i32 0, i32* %6
br label %186
186: ; preds = %217, %185
%187 = load i32, i32* %6
%188 = sext i32 %187 to i64
%189 = load i8**, i8*** %5
%190 = getelementptr inbounds i8*, i8** %189, i64 4
%191 = load i8*, i8** %190
%192 = call i64 @strlen(i8* %191)
%193 = icmp ult i64 %188, %192
br i1 %193, label %194, label %220
194: ; preds = %186
%195 = load i8**, i8*** %5
%196 = getelementptr inbounds i8*, i8** %195, i64 4
%197 = load i8*, i8** %196
%198 = load i32, i32* %6
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %197, i64 %199
%201 = load i8, i8* %200
%202 = sext i8 %201 to i32
%203 = call i32 @isdigit(i32 %202)
%204 = icmp ne i32 %203, 0
br i1 %204, label %216, label %205
205: ; preds = %194
%206 = load i8**, i8*** %5
%207 = getelementptr inbounds i8*, i8** %206, i64 4
%208 = load i8*, i8** %207
%209 = load i32, i32* %6
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i8, i8* %208, i64 %210
%212 = load i8, i8* %211
%213 = sext i8 %212 to i32
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.23, i64 0, i64 0), i32 %213)
%215 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 5, i32* %3
br label %610
216: ; preds = %194
br label %217
217: ; preds = %216
%218 = load i32, i32* %6
%219 = add nsw i32 %218, 1
store i32 %219, i32* %6
br label %186
220: ; preds = %186
%221 = load i8**, i8*** %5
%222 = getelementptr inbounds i8*, i8** %221, i64 4
%223 = load i8*, i8** %222
%224 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %223)
store i32 %224, i32* %19
br label %225
225: ; preds = %138, %220
%226 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%227 = load i8**, i8*** %5
%228 = getelementptr inbounds i8*, i8** %227, i64 3
%229 = load i8*, i8** %228
%230 = call i8* @strcpy(i8* %226, i8* %229)
%231 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%232 = call i64 @strlen(i8* %231)
%233 = icmp ugt i64 %232, 15
br i1 %233, label %238, label %234
234: ; preds = %225
%235 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%236 = call i64 @strlen(i8* %235)
%237 = icmp ult i64 %236, 7
br i1 %237, label %238, label %246
238: ; preds = %234, %225
%239 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%240 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.24, i64 0, i64 0), i8* %239)
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.25, i64 0, i64 0))
%242 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%243 = call i64 @strlen(i8* %242)
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.26, i64 0, i64 0), i64 %243)
%245 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 6, i32* %3
br label %610
246: ; preds = %234
store i32 0, i32* %6
br label %247
247: ; preds = %285, %246
%248 = load i32, i32* %6
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%251 = call i64 @strlen(i8* %250)
%252 = icmp ult i64 %249, %251
br i1 %252, label %253, label %288
253: ; preds = %247
%254 = load i32, i32* %6
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 %255
%257 = load i8, i8* %256
%258 = sext i8 %257 to i32
%259 = call i32 @isdigit(i32 %258)
%260 = icmp ne i32 %259, 0
br i1 %260, label %284, label %261
261: ; preds = %253
%262 = load i32, i32* %6
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 %263
%265 = load i8, i8* %264
%266 = sext i8 %265 to i32
%267 = icmp ne i32 %266, 46
br i1 %267, label %268, label %284
268: ; preds = %261
%269 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%270 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.27, i64 0, i64 0), i8* %269)
%271 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i64 0, i64 0))
store i32 0, i32* %7
br label %272
272: ; preds = %278, %268
%273 = load i32, i32* %7
%274 = load i32, i32* %6
%275 = icmp slt i32 %273, %274
br i1 %275, label %276, label %281
276: ; preds = %272
%277 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.29, i64 0, i64 0))
br label %278
278: ; preds = %276
%279 = load i32, i32* %7
%280 = add nsw i32 %279, 1
store i32 %280, i32* %7
br label %272
281: ; preds = %272
%282 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.30, i64 0, i64 0))
%283 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 7, i32* %3
br label %610
284: ; preds = %261, %253
br label %285
285: ; preds = %284
%286 = load i32, i32* %6
%287 = add nsw i32 %286, 1
store i32 %287, i32* %6
br label %247
288: ; preds = %247
store i32 0, i32* %6
store i32 0, i32* %8
store i32 0, i32* %7
br label %289
289: ; preds = %372, %288
%290 = load i32, i32* %7
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%293 = call i64 @strlen(i8* %292)
%294 = icmp ule i64 %291, %293
br i1 %294, label %295, label %375
295: ; preds = %289
%296 = load i32, i32* %7
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 %297
%299 = load i8, i8* %298
%300 = sext i8 %299 to i32
%301 = icmp ne i32 %300, 46
br i1 %301, label %302, label %321
302: ; preds = %295
%303 = load i32, i32* %7
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 %304
%306 = load i8, i8* %305
%307 = sext i8 %306 to i32
%308 = icmp ne i32 %307, 0
br i1 %308, label %309, label %321
309: ; preds = %302
%310 = load i32, i32* %7
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 %311
%313 = load i8, i8* %312
%314 = load i32, i32* %6
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %15, i64 0, i64 %315
%317 = load i32, i32* %8
%318 = add nsw i32 %317, 1
store i32 %318, i32* %8
%319 = sext i32 %317 to i64
%320 = getelementptr inbounds [5 x i8], [5 x i8]* %316, i64 0, i64 %319
store i8 %313, i8* %320
br label %371
321: ; preds = %302, %295
%322 = load i32, i32* %8
%323 = icmp slt i32 %322, 1
br i1 %323, label %327, label %324
324: ; preds = %321
%325 = load i32, i32* %8
%326 = icmp sgt i32 %325, 3
br i1 %326, label %327, label %333
327: ; preds = %324, %321
%328 = load i32, i32* %6
%329 = add nsw i32 %328, 1
%330 = load i32, i32* %8
%331 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.31, i64 0, i64 0), i32 %329, i32 %330)
%332 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 8, i32* %3
br label %610
333: ; preds = %324
%334 = load i32, i32* %6
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %15, i64 0, i64 %335
%337 = load i32, i32* %8
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [5 x i8], [5 x i8]* %336, i64 0, i64 %338
store i8 0, i8* %339
%340 = load i32, i32* %6
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %15, i64 0, i64 %341
%343 = getelementptr inbounds [5 x i8], [5 x i8]* %342, i64 0, i64 0
%344 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %343)
%345 = load i32, i32* %6
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %346
store i32 %344, i32* %347
%348 = load i32, i32* %6
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %349
%351 = load i32, i32* %350
%352 = icmp slt i32 %351, 0
br i1 %352, label %359, label %353
353: ; preds = %333
%354 = load i32, i32* %6
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %355
%357 = load i32, i32* %356
%358 = icmp sgt i32 %357, 255
br i1 %358, label %359, label %368
359: ; preds = %353, %333
%360 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%361 = load i32, i32* %6
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %362
%364 = load i32, i32* %363
%365 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.32, i64 0, i64 0), i8* %360, i32 %364)
%366 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.33, i64 0, i64 0))
%367 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 9, i32* %3
br label %610
368: ; preds = %353
%369 = load i32, i32* %6
%370 = add nsw i32 %369, 1
store i32 %370, i32* %6
store i32 0, i32* %8
br label %371
371: ; preds = %368, %309
br label %372
372: ; preds = %371
%373 = load i32, i32* %7
%374 = add nsw i32 %373, 1
store i32 %374, i32* %7
br label %289
375: ; preds = %289
%376 = load i32, i32* %6
%377 = icmp ne i32 %376, 4
br i1 %377, label %378, label %382
378: ; preds = %375
%379 = load i32, i32* %6
%380 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.34, i64 0, i64 0), i32 %379)
%381 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 10, i32* %3
br label %610
382: ; preds = %375
store i64 0, i64* %17
store i32 0, i32* %6
br label %383
383: ; preds = %396, %382
%384 = load i32, i32* %6
%385 = icmp slt i32 %384, 3
br i1 %385, label %386, label %399
386: ; preds = %383
%387 = load i32, i32* %6
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %388
%390 = load i32, i32* %389
%391 = sext i32 %390 to i64
%392 = load i64, i64* %17
%393 = or i64 %391, %392
store i64 %393, i64* %17
%394 = load i64, i64* %17
%395 = shl i64 %394, 8
store i64 %395, i64* %17
br label %396
396: ; preds = %386
%397 = load i32, i32* %6
%398 = add nsw i32 %397, 1
store i32 %398, i32* %6
br label %383
399: ; preds = %383
%400 = load i32, i32* %6
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 %401
%403 = load i32, i32* %402
%404 = sext i32 %403 to i64
%405 = load i64, i64* %17
%406 = or i64 %404, %405
store i64 %406, i64* %17
br label %407
407: ; preds = %138, %399
%408 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%409 = load i8**, i8*** %5
%410 = getelementptr inbounds i8*, i8** %409, i64 2
%411 = load i8*, i8** %410
%412 = call i8* @strcpy(i8* %408, i8* %411)
%413 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%414 = call i64 @strlen(i8* %413)
%415 = icmp ugt i64 %414, 15
br i1 %415, label %420, label %416
416: ; preds = %407
%417 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%418 = call i64 @strlen(i8* %417)
%419 = icmp ult i64 %418, 7
br i1 %419, label %420, label %428
420: ; preds = %416, %407
%421 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%422 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.24, i64 0, i64 0), i8* %421)
%423 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.25, i64 0, i64 0))
%424 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%425 = call i64 @strlen(i8* %424)
%426 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.26, i64 0, i64 0), i64 %425)
%427 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 11, i32* %3
br label %610
428: ; preds = %416
store i32 0, i32* %6
br label %429
429: ; preds = %467, %428
%430 = load i32, i32* %6
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%433 = call i64 @strlen(i8* %432)
%434 = icmp ult i64 %431, %433
br i1 %434, label %435, label %470
435: ; preds = %429
%436 = load i32, i32* %6
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %437
%439 = load i8, i8* %438
%440 = sext i8 %439 to i32
%441 = call i32 @isdigit(i32 %440)
%442 = icmp ne i32 %441, 0
br i1 %442, label %466, label %443
443: ; preds = %435
%444 = load i32, i32* %6
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %445
%447 = load i8, i8* %446
%448 = sext i8 %447 to i32
%449 = icmp ne i32 %448, 46
br i1 %449, label %450, label %466
450: ; preds = %443
%451 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%452 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.27, i64 0, i64 0), i8* %451)
%453 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i64 0, i64 0))
store i32 0, i32* %7
br label %454
454: ; preds = %460, %450
%455 = load i32, i32* %7
%456 = load i32, i32* %6
%457 = icmp slt i32 %455, %456
br i1 %457, label %458, label %463
458: ; preds = %454
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.29, i64 0, i64 0))
br label %460
460: ; preds = %458
%461 = load i32, i32* %7
%462 = add nsw i32 %461, 1
store i32 %462, i32* %7
br label %454
463: ; preds = %454
%464 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.30, i64 0, i64 0))
%465 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 12, i32* %3
br label %610
466: ; preds = %443, %435
br label %467
467: ; preds = %466
%468 = load i32, i32* %6
%469 = add nsw i32 %468, 1
store i32 %469, i32* %6
br label %429
470: ; preds = %429
store i32 0, i32* %6
store i32 0, i32* %8
store i32 0, i32* %7
br label %471
471: ; preds = %554, %470
%472 = load i32, i32* %7
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%475 = call i64 @strlen(i8* %474)
%476 = icmp ule i64 %473, %475
br i1 %476, label %477, label %557
477: ; preds = %471
%478 = load i32, i32* %7
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %479
%481 = load i8, i8* %480
%482 = sext i8 %481 to i32
%483 = icmp ne i32 %482, 46
br i1 %483, label %484, label %503
484: ; preds = %477
%485 = load i32, i32* %7
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %486
%488 = load i8, i8* %487
%489 = sext i8 %488 to i32
%490 = icmp ne i32 %489, 0
br i1 %490, label %491, label %503
491: ; preds = %484
%492 = load i32, i32* %7
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %493
%495 = load i8, i8* %494
%496 = load i32, i32* %6
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %11, i64 0, i64 %497
%499 = load i32, i32* %8
%500 = add nsw i32 %499, 1
store i32 %500, i32* %8
%501 = sext i32 %499 to i64
%502 = getelementptr inbounds [5 x i8], [5 x i8]* %498, i64 0, i64 %501
store i8 %495, i8* %502
br label %553
503: ; preds = %484, %477
%504 = load i32, i32* %8
%505 = icmp slt i32 %504, 1
br i1 %505, label %509, label %506
506: ; preds = %503
%507 = load i32, i32* %8
%508 = icmp sgt i32 %507, 3
br i1 %508, label %509, label %515
509: ; preds = %506, %503
%510 = load i32, i32* %6
%511 = add nsw i32 %510, 1
%512 = load i32, i32* %8
%513 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.31, i64 0, i64 0), i32 %511, i32 %512)
%514 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 13, i32* %3
br label %610
515: ; preds = %506
%516 = load i32, i32* %6
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %11, i64 0, i64 %517
%519 = load i32, i32* %8
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds [5 x i8], [5 x i8]* %518, i64 0, i64 %520
store i8 0, i8* %521
%522 = load i32, i32* %6
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %11, i64 0, i64 %523
%525 = getelementptr inbounds [5 x i8], [5 x i8]* %524, i64 0, i64 0
%526 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %525)
%527 = load i32, i32* %6
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %528
store i32 %526, i32* %529
%530 = load i32, i32* %6
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %531
%533 = load i32, i32* %532
%534 = icmp slt i32 %533, 0
br i1 %534, label %541, label %535
535: ; preds = %515
%536 = load i32, i32* %6
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %537
%539 = load i32, i32* %538
%540 = icmp sgt i32 %539, 255
br i1 %540, label %541, label %550
541: ; preds = %535, %515
%542 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%543 = load i32, i32* %6
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %544
%546 = load i32, i32* %545
%547 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.32, i64 0, i64 0), i8* %542, i32 %546)
%548 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.33, i64 0, i64 0))
%549 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 14, i32* %3
br label %610
550: ; preds = %535
%551 = load i32, i32* %6
%552 = add nsw i32 %551, 1
store i32 %552, i32* %6
store i32 0, i32* %8
br label %553
553: ; preds = %550, %491
br label %554
554: ; preds = %553
%555 = load i32, i32* %7
%556 = add nsw i32 %555, 1
store i32 %556, i32* %7
br label %471
557: ; preds = %471
%558 = load i32, i32* %6
%559 = icmp ne i32 %558, 4
br i1 %559, label %560, label %564
560: ; preds = %557
%561 = load i32, i32* %6
%562 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.34, i64 0, i64 0), i32 %561)
%563 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.20, i64 0, i64 0))
store i32 15, i32* %3
br label %610
564: ; preds = %557
store i64 0, i64* %13
store i32 0, i32* %6
br label %565
565: ; preds = %578, %564
%566 = load i32, i32* %6
%567 = icmp slt i32 %566, 3
br i1 %567, label %568, label %581
568: ; preds = %565
%569 = load i32, i32* %6
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %570
%572 = load i32, i32* %571
%573 = sext i32 %572 to i64
%574 = load i64, i64* %13
%575 = or i64 %573, %574
store i64 %575, i64* %13
%576 = load i64, i64* %13
%577 = shl i64 %576, 8
store i64 %577, i64* %13
br label %578
578: ; preds = %568
%579 = load i32, i32* %6
%580 = add nsw i32 %579, 1
store i32 %580, i32* %6
br label %565
581: ; preds = %565
%582 = load i32, i32* %6
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 %583
%585 = load i32, i32* %584
%586 = sext i32 %585 to i64
%587 = load i64, i64* %13
%588 = or i64 %586, %587
store i64 %588, i64* %13
br label %589
589: ; preds = %581, %138
%590 = getelementptr inbounds [3 x i8], [3 x i8]* %9, i64 0, i64 0
%591 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 0
%592 = load i32, i32* %591
%593 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 1
%594 = load i32, i32* %593
%595 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 2
%596 = load i32, i32* %595
%597 = getelementptr inbounds [4 x i32], [4 x i32]* %12, i64 0, i64 3
%598 = load i32, i32* %597
%599 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 0
%600 = load i32, i32* %599
%601 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 1
%602 = load i32, i32* %601
%603 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 2
%604 = load i32, i32* %603
%605 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 3
%606 = load i32, i32* %605
%607 = load i32, i32* %19
%608 = load i32, i32* %21
%609 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([112 x i8], [112 x i8]* @.str.35, i64 0, i64 0), i8* %590, i32 %592, i32 %594, i32 %596, i32 %598, i32 %600, i32 %602, i32 %604, i32 %606, i32 %607, i32 %608)
store i32 0, i32* %3
br label %610
610: ; preds = %589, %560, %541, %509, %463, %420, %378, %359, %327, %281, %238, %205, %165, %123, %95, %44
%611 = load i32, i32* %3
ret i32 %611
}

LLVM IR (-O2):
@.str.18 = [129 x i8] c" %s <classifierEngineIndex (hex, without 0x)> [<SA (dotted decimal)> [<DA (dotted decimal)> [<SP (decimal)> [<DP (decimal)>]]]]\0A\00"
@.str.19 = [54 x i8] c"Sorry, %s is too long (should be less then 3 chars).\0A\00"
@.str.21 = [37 x i8] c"Sorry, %c is not a valid hex digit.\0A\00"
@.str.22 = [37 x i8] c"Sorry, %c is not a valid dec digit.\0A\00"
@.str.23 = [37 x i8] c"Sorry, %s is not a valid dec digit.\0A\00"
@.str.24 = [45 x i8] c"Sorry, %s is not a valid IP address in hex.\0A\00"
@.str.25 = [34 x i8] c"It has the wrong number of digits\00"
@.str.26 = [35 x i8] c" (%d, expected between 7 and 15).\0A\00"
@.str.27 = [56 x i8] c"Sorry, %s is not a valid IP address in dotted decimal.\0A\00"
@.str.28 = [8 x i8] c" \00"
@.str.31 = [55 x i8] c"Sorry, octet #%d has the wrong number of digits (%d).\0A\00"
@.str.32 = [46 x i8] c"Sorry, %s contains an invalid IP octet (%d).\0A\00"
@.str.34 = [48 x i8] c"Sorry, wrong number of octets (%d, expected 4)\0A\00"
@.str.35 = [112 x i8] c"camClassFind 0x80000000,0x%s0600%02.2X,0x%02.2X%02.2X%02.2X%02.2X,0x800000%02.2X,0x%02.2X%02.2X%04.4X,0x%X8000\0A\00"
@str.43 = [28 x i8] c"It must be >= 0 and <= 255.\00"
@str.46 = [2 x i8] c"^\00"
@str.52 = [31 x i8] c"Please try again. Exiting ...\00"
@str.53 = [70 x i8] c" This C program generates the following eSeries LM-10 shell command:\00"
@str.54 = [82 x i8] c" camClassFind 0x80000000,0xii0600ss,0xssssssdd,0x800000dd,0xddddpppp,0xPPPP8000\00"
@str.55 = [8 x i8] c" ii =\00"
@str.56 = [95 x i8] c" <classifierEngineIndex> from the \22showPolicy <policyId>\22 eSeries SRP shell command output;\00"
@str.57 = [133 x i8] c" <policyId> is the last hex number on the \22Policy <inPolicy>...\22 line from the \22showPolicyIds\22 eSeries SRP shell command output;\00"
@str.58 = [147 x i8] c" <inPolicy> is the last word from the \22ip policy input <inPolicy>\22 line in the \22show configuration interface <interFaceTyp> <interfaceNumber>\22\00"
@str.59 = [34 x i8] c" sSeries CLI command output.\00"
@str.60 = [21 x i8] c" ssssssss = <SA> =\00"
@str.61 = [56 x i8] c" source ip address (default is 1.1.1.1 = 0x01010101)\00"
@str.62 = [21 x i8] c" dddddddd = <DA> =\00"
@str.63 = [61 x i8] c" destination ip address (default is 2.2.2.2 = 0x02020202)\00"
@str.64 = [17 x i8] c" pppp = <SP> =\00"
@str.65 = [55 x i8] c" source port (default is 2000 = 0x07D0 = ephemeral)\00"
@str.66 = [17 x i8] c" ssss = <DP> =\00"
@str.67 = [51 x i8] c" destination port (default is 25 = 0x19 = SMTP)\00"
@str.68 = [153 x i8] c" Refer to 2011-0111-0591, KA<tbd> and/or the \22http://www-int.juniper.net/customerservice/jtac/techdocs/ERX/docs/junose_shell_command_reference.pdf\22 doc\00"
@str.69 = [64 x i8] c" Written by Jonathan Natale for Juniper Networks on 19-Feb-11.\00"
@str.70 = [7 x i8] c"Usage:\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [3 x i8]
%4 = alloca [16 x i8]
%5 = alloca [4 x [5 x i8]]
%6 = alloca <4 x i32>
%7 = alloca [16 x i8]
%8 = alloca [4 x [5 x i8]]
%9 = alloca <4 x i32>
%10 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%11 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 0
%12 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %5, i64 0, i64 0, i64 0
%13 = bitcast <4 x i32>* %6 to i8*
%14 = getelementptr inbounds [16 x i8], [16 x i8]* %7, i64 0, i64 0
%15 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %8, i64 0, i64 0, i64 0
%16 = bitcast <4 x i32>* %9 to i8*
%17 = add i32 %0, -7
%18 = icmp ult i32 %17, -5
br i1 %18, label %34, label %19
19: ; preds = %2
%20 = getelementptr inbounds i8*, i8** %1, i64 1
%21 = load i8*, i8** %20
%22 = load i8, i8* %21
switch i8 %22, label %23 [
i8 63, label %34
i8 104, label %34
]
23: ; preds = %19
%24 = getelementptr inbounds <4 x i32>, <4 x i32>* %6, i64 0, i64 0
%25 = getelementptr inbounds <4 x i32>, <4 x i32>* %6, i64 0, i64 1
%26 = getelementptr inbounds <4 x i32>, <4 x i32>* %6, i64 0, i64 2
%27 = getelementptr inbounds <4 x i32>, <4 x i32>* %6, i64 0, i64 3
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %6
%28 = getelementptr inbounds <4 x i32>, <4 x i32>* %9, i64 0, i64 0
%29 = getelementptr inbounds <4 x i32>, <4 x i32>* %9, i64 0, i64 1
%30 = getelementptr inbounds <4 x i32>, <4 x i32>* %9, i64 0, i64 2
%31 = getelementptr inbounds <4 x i32>, <4 x i32>* %9, i64 0, i64 3
store <4 x i32> <i32 2, i32 2, i32 2, i32 2>, <4 x i32>* %9
%32 = tail call i64 @strlen(i8* dereferenceable(1) %21)
%33 = icmp ugt i64 %32, 2
br i1 %33, label %61, label %55
34: ; preds = %19, %19, %2
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.53, i64 0, i64 0))
%36 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([82 x i8], [82 x i8]* @str.54, i64 0, i64 0))
%37 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.55, i64 0, i64 0))
%38 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([95 x i8], [95 x i8]* @str.56, i64 0, i64 0))
%39 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([133 x i8], [133 x i8]* @str.57, i64 0, i64 0))
%40 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([147 x i8], [147 x i8]* @str.58, i64 0, i64 0))
%41 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.59, i64 0, i64 0))
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.60, i64 0, i64 0))
%43 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str.61, i64 0, i64 0))
%44 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.62, i64 0, i64 0))
%45 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str.63, i64 0, i64 0))
%46 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.64, i64 0, i64 0))
%47 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @str.65, i64 0, i64 0))
%48 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.66, i64 0, i64 0))
%49 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.67, i64 0, i64 0))
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([153 x i8], [153 x i8]* @str.68, i64 0, i64 0))
%51 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.69, i64 0, i64 0))
%52 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @str.70, i64 0, i64 0))
%53 = load i8*, i8** %1
%54 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([129 x i8], [129 x i8]* @.str.18, i64 0, i64 0), i8* %53)
br label %314
55: ; preds = %23
%56 = icmp eq i64 %32, 0
br i1 %56, label %82, label %57
57: ; preds = %55
%58 = sext i8 %22 to i32
%59 = tail call i32 @isxdigit(i32 %58)
%60 = icmp eq i32 %59, 0
br i1 %60, label %78, label %66
61: ; preds = %23
%62 = getelementptr inbounds i8*, i8** %1, i64 4
%63 = load i8*, i8** %62
%64 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @.str.19, i64 0, i64 0), i8* %63)
%65 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
66: ; preds = %57, %69
%67 = phi i64 [ %75, %69 ], [ 1, %57 ]
%68 = icmp eq i64 %67, %32
br i1 %68, label %82, label %69
69: ; preds = %66
%70 = getelementptr inbounds i8, i8* %21, i64 %67
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = tail call i32 @isxdigit(i32 %72)
%74 = icmp eq i32 %73, 0
%75 = add nuw i64 %67, 1
br i1 %74, label %76, label %66
76: ; preds = %69
%77 = sext i8 %71 to i32
br label %78
78: ; preds = %76, %57
%79 = phi i32 [ %58, %57 ], [ %77, %76 ]
%80 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.21, i64 0, i64 0), i32 %79)
%81 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
82: ; preds = %66, %55
%83 = call i8* @strcpy(i8* %10, i8* dereferenceable(1) %21)
switch i32 %0, label %302 [
i32 6, label %84
i32 5, label %105
i32 4, label %127
i32 3, label %210
]
84: ; preds = %82
%85 = getelementptr inbounds i8*, i8** %1, i64 5
%86 = load i8*, i8** %85
%87 = call i64 @strlen(i8* dereferenceable(1) %86)
%88 = icmp eq i64 %87, 0
br i1 %88, label %103, label %91
89: ; preds = %91
%90 = icmp eq i64 %98, %87
br i1 %90, label %103, label %91
91: ; preds = %84, %89
%92 = phi i64 [ %98, %89 ], [ 0, %84 ]
%93 = getelementptr inbounds i8, i8* %86, i64 %92
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = add nsw i32 %95, -48
%97 = icmp ult i32 %96, 10
%98 = add nuw i64 %92, 1
br i1 %97, label %89, label %99
99: ; preds = %91
%100 = sext i8 %94 to i32
%101 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.22, i64 0, i64 0), i32 %100)
%102 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
103: ; preds = %89, %84
%104 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %86)
br label %105
105: ; preds = %82, %103
%106 = phi i32 [ 25, %82 ], [ %104, %103 ]
%107 = getelementptr inbounds i8*, i8** %1, i64 4
%108 = load i8*, i8** %107
%109 = call i64 @strlen(i8* dereferenceable(1) %108)
%110 = icmp eq i64 %109, 0
br i1 %110, label %125, label %113
111: ; preds = %113
%112 = icmp eq i64 %120, %109
br i1 %112, label %125, label %113
113: ; preds = %105, %111
%114 = phi i64 [ %120, %111 ], [ 0, %105 ]
%115 = getelementptr inbounds i8, i8* %108, i64 %114
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = add nsw i32 %117, -48
%119 = icmp ult i32 %118, 10
%120 = add nuw i64 %114, 1
br i1 %119, label %111, label %121
121: ; preds = %113
%122 = sext i8 %116 to i32
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.23, i64 0, i64 0), i32 %122)
%124 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
125: ; preds = %111, %105
%126 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %108)
br label %127
127: ; preds = %82, %125
%128 = phi i32 [ 2000, %82 ], [ %126, %125 ]
%129 = phi i32 [ 25, %82 ], [ %106, %125 ]
%130 = getelementptr inbounds i8*, i8** %1, i64 3
%131 = load i8*, i8** %130
%132 = call i8* @strcpy(i8* %14, i8* dereferenceable(1) %131)
%133 = call i64 @strlen(i8* %14)
%134 = add i64 %133, -16
%135 = icmp ult i64 %134, -9
br i1 %135, label %136, label %142
136: ; preds = %127
%137 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.24, i64 0, i64 0), i8* %14)
%138 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.25, i64 0, i64 0))
%139 = call i64 @strlen(i8* %14)
%140 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.26, i64 0, i64 0), i64 %139)
%141 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
142: ; preds = %127, %164
%143 = phi i64 [ %165, %164 ], [ 0, %127 ]
%144 = getelementptr inbounds [16 x i8], [16 x i8]* %7, i64 0, i64 %143
%145 = load i8, i8* %144
%146 = sext i8 %145 to i32
%147 = add nsw i32 %146, -48
%148 = icmp ult i32 %147, 10
%149 = icmp eq i8 %145, 46
%150 = select i1 %148, i1 true, i1 %149
br i1 %150, label %164, label %151
151: ; preds = %142
%152 = trunc i64 %143 to i32
%153 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.27, i64 0, i64 0), i8* %14)
%154 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i64 0, i64 0))
%155 = icmp eq i32 %152, 0
br i1 %155, label %161, label %156
156: ; preds = %151, %156
%157 = phi i32 [ %159, %156 ], [ 0, %151 ]
%158 = call i32 @putchar(i32 32)
%159 = add nuw i32 %157, 1
%160 = icmp eq i32 %159, %152
br i1 %160, label %161, label %156
161: ; preds = %156, %151
%162 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.46, i64 0, i64 0))
%163 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
164: ; preds = %142
%165 = add nuw i64 %143, 1
%166 = icmp eq i64 %165, %133
br i1 %166, label %167, label %142
167: ; preds = %164, %199
%168 = phi i64 [ %202, %199 ], [ 0, %164 ]
%169 = phi i32 [ %201, %199 ], [ 0, %164 ]
%170 = phi i32 [ %200, %199 ], [ 0, %164 ]
%171 = getelementptr inbounds [16 x i8], [16 x i8]* %7, i64 0, i64 %168
%172 = load i8, i8* %171
switch i8 %172, label %173 [
i8 46, label %178
i8 0, label %178
]
173: ; preds = %167
%174 = sext i32 %169 to i64
%175 = add nsw i32 %170, 1
%176 = sext i32 %170 to i64
%177 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %8, i64 0, i64 %174, i64 %176
store i8 %172, i8* %177
br label %199
178: ; preds = %167, %167
%179 = add i32 %170, -4
%180 = icmp ult i32 %179, -3
br i1 %180, label %181, label %185
181: ; preds = %178
%182 = add nsw i32 %169, 1
%183 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @.str.31, i64 0, i64 0), i32 %182, i32 %170)
%184 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
185: ; preds = %178
%186 = sext i32 %169 to i64
%187 = zext i32 %170 to i64
%188 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %8, i64 0, i64 %186, i64 %187
store i8 0, i8* %188
%189 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %8, i64 0, i64 %186, i64 0
%190 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %189)
%191 = getelementptr inbounds <4 x i32>, <4 x i32>* %9, i64 0, i64 %186
store i32 %190, i32* %191
%192 = icmp ugt i32 %190, 255
br i1 %192, label %193, label %197
193: ; preds = %185
%194 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.32, i64 0, i64 0), i8* %14, i32 %190)
%195 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.43, i64 0, i64 0))
%196 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
197: ; preds = %185
%198 = add nsw i32 %169, 1
br label %199
199: ; preds = %173, %197
%200 = phi i32 [ %175, %173 ], [ 0, %197 ]
%201 = phi i32 [ %169, %173 ], [ %198, %197 ]
%202 = add nuw i64 %168, 1
%203 = call i64 @strlen(i8* %14)
%204 = icmp ugt i64 %203, %168
br i1 %204, label %167, label %205
205: ; preds = %199
%206 = icmp eq i32 %201, 4
br i1 %206, label %210, label %207
207: ; preds = %205
%208 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.34, i64 0, i64 0), i32 %201)
%209 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
210: ; preds = %205, %82
%211 = phi i32 [ 2000, %82 ], [ %128, %205 ]
%212 = phi i32 [ 25, %82 ], [ %129, %205 ]
%213 = getelementptr inbounds i8*, i8** %1, i64 2
%214 = load i8*, i8** %213
%215 = call i8* @strcpy(i8* %11, i8* dereferenceable(1) %214)
%216 = call i64 @strlen(i8* %11)
%217 = add i64 %216, -16
%218 = icmp ult i64 %217, -9
br i1 %218, label %219, label %225
219: ; preds = %210
%220 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.24, i64 0, i64 0), i8* %11)
%221 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.25, i64 0, i64 0))
%222 = call i64 @strlen(i8* %11)
%223 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.26, i64 0, i64 0), i64 %222)
%224 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
225: ; preds = %210, %247
%226 = phi i64 [ %248, %247 ], [ 0, %210 ]
%227 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 %226
%228 = load i8, i8* %227
%229 = sext i8 %228 to i32
%230 = add nsw i32 %229, -48
%231 = icmp ult i32 %230, 10
%232 = icmp eq i8 %228, 46
%233 = select i1 %231, i1 true, i1 %232
br i1 %233, label %247, label %234
234: ; preds = %225
%235 = trunc i64 %226 to i32
%236 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.27, i64 0, i64 0), i8* %11)
%237 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i64 0, i64 0))
%238 = icmp eq i32 %235, 0
br i1 %238, label %244, label %239
239: ; preds = %234, %239
%240 = phi i32 [ %242, %239 ], [ 0, %234 ]
%241 = call i32 @putchar(i32 32)
%242 = add nuw i32 %240, 1
%243 = icmp eq i32 %242, %235
br i1 %243, label %244, label %239
244: ; preds = %239, %234
%245 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.46, i64 0, i64 0))
%246 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
247: ; preds = %225
%248 = add nuw i64 %226, 1
%249 = icmp eq i64 %248, %216
br i1 %249, label %250, label %225
250: ; preds = %247, %282
%251 = phi i64 [ %285, %282 ], [ 0, %247 ]
%252 = phi i32 [ %284, %282 ], [ 0, %247 ]
%253 = phi i32 [ %283, %282 ], [ 0, %247 ]
%254 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 %251
%255 = load i8, i8* %254
switch i8 %255, label %256 [
i8 46, label %261
i8 0, label %261
]
256: ; preds = %250
%257 = sext i32 %252 to i64
%258 = add nsw i32 %253, 1
%259 = sext i32 %253 to i64
%260 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %5, i64 0, i64 %257, i64 %259
store i8 %255, i8* %260
br label %282
261: ; preds = %250, %250
%262 = add i32 %253, -4
%263 = icmp ult i32 %262, -3
br i1 %263, label %264, label %268
264: ; preds = %261
%265 = add nsw i32 %252, 1
%266 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @.str.31, i64 0, i64 0), i32 %265, i32 %253)
%267 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
268: ; preds = %261
%269 = sext i32 %252 to i64
%270 = zext i32 %253 to i64
%271 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %5, i64 0, i64 %269, i64 %270
store i8 0, i8* %271
%272 = getelementptr inbounds [4 x [5 x i8]], [4 x [5 x i8]]* %5, i64 0, i64 %269, i64 0
%273 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %272)
%274 = getelementptr inbounds <4 x i32>, <4 x i32>* %6, i64 0, i64 %269
store i32 %273, i32* %274
%275 = icmp ugt i32 %273, 255
br i1 %275, label %276, label %280
276: ; preds = %268
%277 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.32, i64 0, i64 0), i8* %11, i32 %273)
%278 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.43, i64 0, i64 0))
%279 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
280: ; preds = %268
%281 = add nsw i32 %252, 1
br label %282
282: ; preds = %256, %280
%283 = phi i32 [ %258, %256 ], [ 0, %280 ]
%284 = phi i32 [ %252, %256 ], [ %281, %280 ]
%285 = add nuw i64 %251, 1
%286 = call i64 @strlen(i8* %11)
%287 = icmp ugt i64 %286, %251
br i1 %287, label %250, label %288
288: ; preds = %282
%289 = icmp eq i32 %284, 4
br i1 %289, label %290, label %299
290: ; preds = %288
%291 = load i32, i32* %24
%292 = load i32, i32* %25
%293 = load i32, i32* %26
%294 = load i32, i32* %27
%295 = load i32, i32* %28
%296 = load i32, i32* %29
%297 = load i32, i32* %30
%298 = load i32, i32* %31
br label %302
299: ; preds = %288
%300 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.34, i64 0, i64 0), i32 %284)
%301 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.52, i64 0, i64 0))
br label %314
302: ; preds = %290, %82
%303 = phi i32 [ 2, %82 ], [ %298, %290 ]
%304 = phi i32 [ 2, %82 ], [ %297, %290 ]
%305 = phi i32 [ 2, %82 ], [ %296, %290 ]
%306 = phi i32 [ 2, %82 ], [ %295, %290 ]
%307 = phi i32 [ 1, %82 ], [ %294, %290 ]
%308 = phi i32 [ 1, %82 ], [ %293, %290 ]
%309 = phi i32 [ 1, %82 ], [ %292, %290 ]
%310 = phi i32 [ 1, %82 ], [ %291, %290 ]
%311 = phi i32 [ 2000, %82 ], [ %211, %290 ]
%312 = phi i32 [ 25, %82 ], [ %212, %290 ]
%313 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @.str.35, i64 0, i64 0), i8* %10, i32 %310, i32 %309, i32 %308, i32 %307, i32 %306, i32 %305, i32 %304, i32 %303, i32 %311, i32 %312)
br label %314
314: ; preds = %302, %299, %276, %264, %244, %219, %207, %193, %181, %161, %136, %121, %99, %78, %61, %34
%315 = phi i32 [ 1, %34 ], [ 2, %61 ], [ 3, %78 ], [ 0, %302 ], [ 11, %219 ], [ 12, %244 ], [ 13, %264 ], [ 14, %276 ], [ 15, %299 ], [ 6, %136 ], [ 7, %161 ], [ 8, %181 ], [ 9, %193 ], [ 10, %207 ], [ 5, %121 ], [ 4, %99 ]
ret i32 %315
}