#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 */

/* Variables and functions */
int /*<<< orphan*/ atoi(char *);
int /*<<< orphan*/ get_annotation(char *, char *);
int /*<<< orphan*/ get_coverage(char *, int /*<<< orphan*/);
int /*<<< orphan*/ get_intervals(char *, int /*<<< orphan*/,
                                 int /*<<< orphan*/);
int getopt(int, char **, char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sprintf(char *, char *, char *, ...);
scalar_t__ strcmp(char *, char *);
int system(char *);
main(int argc, char **argv) {
  extern char *optarg;
  extern int optind;
  int c, err = 0;
  char *length = "default_depth";
  char *length2 = "default_interval_distance";
  static char usage[] = "usage: %s [-d] depth_cutoff [-i] interval_distance \n";
  char *gtf_file;
  char system_command[1000];
  int return_value;
  while ((c = getopt(argc, argv, "d:i:g:")) != -1)
    switch (c) {
    case 'd':
      length = optarg;
      break;
    case 'i':
      length2 = optarg;
      break;
    case 'g':
      gtf_file = optarg;
      break;
    }
  if (strcmp(length, "default_distance") == 0) {
    printf("no parameter was specified so default to 20\n");
  } else {
    printf("depth input was %s\n", length);
  }
  get_coverage(argv[optind], atoi(length));
  get_intervals(argv[optind], atoi(length2), atoi(length));
  get_annotation(argv[optind], gtf_file);
  sprintf(system_command, "cut -f5 %s.tmp3 > percentages.stats", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "grep protein_coding %s.tmp3 | wc -l >> annotation.stats",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "grep lincRNA %s.tmp3 | wc -l >> annotation.stats",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "grep miR %s.tmp3 | wc -l >> annotation.stats",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "grep antisense %s.tmp3 | wc -l >> annotation.stats",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "grep pseudogene %s.tmp3 | wc -l >> annotation.stats",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "cut -f6 %s.tmp2 > length.stats", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "cut -f7 %s.tmp2 > libsize.stats", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm %s.tmp2", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm %s.tmp", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm tmp.gtf", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "mv %s.tmp3 %s.results", argv[optind], argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"x<-scan(\\\"percentages.stats\\\")\" > graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"hist(x, main=NULL, xlab=\\\"Percentage\\\")\" >> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"y<-scan(\\\"annotation.stats\\\")\" >> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"z<-c(\\\"protein_coding\\\", \\\"lincRNA\\\", \\\"miR\\\", "
          "\\\"antisense\\\", \\\"pseudogene\\\")\" >> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"barplot(y, names.arg=z, main=NULL, ylab=\\\"Frequency\\\")\" "
          ">> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "echo \"w<-scan(\\\"length.stats\\\")\" >> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"hist(log(w), main=NULL, xlab=\\\"log(coverage island "
          "length)\\\")\" >> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "echo \"t<-scan(\\\"libsize.stats\\\")\" >> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command,
          "echo \"boxplot(log(t), main=NULL, ylab=\\\"log(library size)\\\")\" "
          ">> graphs.R",
          argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "echo \"dev.off()\" >> graphs.R", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "R CMD BATCH graphs.R", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "mv Rplots.pdf %s.pdf", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm graphs.R", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm *stats", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm *.Rout", argv[optind]);
  return_value = system(system_command);
  sprintf(system_command, "rm *.pileup", argv[optind]);
  return_value = system(system_command);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x440,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
lea    0xe49(%rip),%rax
mov    %rax,-0x20(%rbp)
lea    0xe4c(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    0xe54(%rip),%rdx
call   1090 <getopt@plt>
mov    %eax,-0x14(%rbp)
cmp    $0xffffffff,%eax
je     125d <main+0xcd>
mov    -0x14(%rbp),%eax
mov    %eax,-0x428(%rbp)
sub    $0x64,%eax
je     1224 <main+0x94>
jmp    11fc <main+0x6c>
mov    -0x428(%rbp),%eax
sub    $0x67,%eax
je     124a <main+0xba>
jmp    1210 <main+0x80>
mov    -0x428(%rbp),%eax
sub    $0x69,%eax
je     1237 <main+0xa7>
jmp    1258 <main+0xc8>
mov    0x2db5(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x20(%rbp)
jmp    1258 <main+0xc8>
mov    0x2da2(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
jmp    1258 <main+0xc8>
mov    0x2d8f(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
jmp    11c6 <main+0x36>
mov    -0x20(%rbp),%rdi
lea    0xdc7(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%rax
jne    128a <main+0xfa>
lea    0xdc2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    129c <main+0x10c>
mov    -0x20(%rbp),%rsi
lea    0xdd8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x2d31(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x440(%rbp)
mov    -0x20(%rbp),%rdi
call   10a0 <atoi@plt>
mov    -0x440(%rbp),%rdi
mov    %eax,%esi
call   1080 <get_coverage@plt>
mov    -0x10(%rbp),%rax
mov    0x2d01(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x438(%rbp)
mov    -0x28(%rbp),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x42c(%rbp)
mov    -0x20(%rbp),%rdi
call   10a0 <atoi@plt>
mov    -0x438(%rbp),%rdi
mov    -0x42c(%rbp),%esi
mov    %eax,%edx
call   1030 <get_intervals@plt>
mov    -0x10(%rbp),%rax
mov    0x2cbc(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rsi
call   1070 <get_annotation@plt>
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2c9a(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd35(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2c61(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd20(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2c28(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd1f(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2bef(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd17(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2bb6(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd0b(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2b7d(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd05(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2b44(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd00(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2b0b(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xce6(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2ad2(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xccd(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2a99(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc9f(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2a60(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc70(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2a27(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    0x2a15(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rcx
lea    0xc30(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x29dc(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc0d(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x29a3(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc05(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x296a(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc07(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2931(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xbff(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x28f8(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc27(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x28bf(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc38(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2886(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc2c(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x284d(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc44(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2814(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc39(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x27db(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc4a(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x27a2(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc2e(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2769(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xc0a(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2730(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xbe6(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x26f7(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xbb9(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x26be(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xb8a(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
lea    -0x420(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2685(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xb5b(%rip),%rsi
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x420(%rbp),%rdi
call   1040 <system@plt>
mov    %eax,-0x424(%rbp)
mov    -0x4(%rbp),%eax
add    $0x440,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3f8,%rsp
mov    %rsi,%r13
mov    %edi,%ebp
lea    0xe43(%rip),%r15
lea    0xe4a(%rip),%r14
lea    0xe5d(%rip),%rbx
mov    0x2e0e(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
call   10a0 <getopt@plt>
cmp    $0x66,%eax
jg     1210 <main+0x70>
cmp    $0xffffffff,%eax
je     122b <main+0x8b>
cmp    $0x64,%eax
jne    11e0 <main+0x40>
mov    (%r12),%r15
jmp    11e0 <main+0x40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x67,%eax
je     1220 <main+0x80>
cmp    $0x69,%eax
jne    11e0 <main+0x40>
mov    (%r12),%r14
jmp    11e0 <main+0x40>
mov    (%r12),%rax
mov    %rax,0x8(%rsp)
jmp    11e0 <main+0x40>
lea    0xdfd(%rip),%rsi
mov    %r15,%rdi
call   1070 <strcmp@plt>
test   %rax,%rax
je     1252 <main+0xb2>
lea    0xdfa(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    125e <main+0xbe>
lea    0x1242(%rip),%rdi
call   1040 <puts@plt>
mov    0x2d73(%rip),%r12
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rbx
mov    %r15,%rdi
call   10b0 <atoi@plt>
mov    %rbx,%rdi
mov    %eax,%esi
call   1090 <get_coverage@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rbx
mov    %r14,%rdi
call   10b0 <atoi@plt>
mov    %eax,%ebp
mov    %r15,%rdi
call   10b0 <atoi@plt>
mov    %rbx,%rdi
mov    %ebp,%esi
mov    %eax,%edx
call   1030 <get_intervals@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdi
mov    0x8(%rsp),%rsi
call   1080 <get_annotation@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xd8a(%rip),%rsi
lea    0x10(%rsp),%r14
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xd87(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xd9d(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdac(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdb7(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdc8(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdda(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdd7(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdd5(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdbe(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xda6(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rcx
lea    0xd8f(%rip),%rsi
mov    %r14,%rdi
mov    %rcx,%rdx
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xd80(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xd8f(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xda8(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdb7(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xdf6(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe1e(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe29(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe58(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe64(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe8c(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe87(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe7a(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe6d(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe57(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe3f(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
movslq (%r12),%rax
mov    0x0(%r13,%rax,8),%rdx
lea    0xe27(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   10c0 <sprintf@plt>
mov    %r14,%rdi
call   1050 <system@plt>
xor    %eax,%eax
add    $0x3f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [14 x i8] c"default_depth\00"
@.str.1 = [26 x i8] c"default_interval_distance\00"
@main.usage = internal global [53 x i8] c"usage: %s [-d] depth_cutoff [-i] interval_distance \0A\00"
@.str.2 = [7 x i8] c"d:i:g:\00"
@optarg = external global i8*
@.str.3 = [17 x i8] c"default_distance\00"
@.str.4 = [45 x i8] c"no parameter was specified so default to 20\0A\00"
@.str.5 = [20 x i8] c"depth input was %s\0A\00"
@optind = external global i32
@.str.6 = [36 x i8] c"cut -f5 %s.tmp3 > percentages.stats\00"
@.str.7 = [56 x i8] c"grep protein_coding %s.tmp3 | wc -l >> annotation.stats\00"
@.str.8 = [49 x i8] c"grep lincRNA %s.tmp3 | wc -l >> annotation.stats\00"
@.str.9 = [45 x i8] c"grep miR %s.tmp3 | wc -l >> annotation.stats\00"
@.str.10 = [51 x i8] c"grep antisense %s.tmp3 | wc -l >> annotation.stats\00"
@.str.11 = [52 x i8] c"grep pseudogene %s.tmp3 | wc -l >> annotation.stats\00"
@.str.12 = [31 x i8] c"cut -f6 %s.tmp2 > length.stats\00"
@.str.13 = [32 x i8] c"cut -f7 %s.tmp2 > libsize.stats\00"
@.str.14 = [11 x i8] c"rm %s.tmp2\00"
@.str.15 = [10 x i8] c"rm %s.tmp\00"
@.str.16 = [11 x i8] c"rm tmp.gtf\00"
@.str.17 = [22 x i8] c"mv %s.tmp3 %s.results\00"
@.str.18 = [49 x i8] c"echo \22x<-scan(\\\22percentages.stats\\\22)\22 > graphs.R\00"
@.str.19 = [59 x i8] c"echo \22hist(x, main=NULL, xlab=\\\22Percentage\\\22)\22 >> graphs.R\00"
@.str.20 = [49 x i8] c"echo \22y<-scan(\\\22annotation.stats\\\22)\22 >> graphs.R\00"
@.str.21 = [97 x i8] c"echo \22z<-c(\\\22protein_coding\\\22, \\\22lincRNA\\\22, \\\22miR\\\22, \\\22antisense\\\22, \\\22pseudogene\\\22)\22 >> graphs.R\00"
@.str.22 = [74 x i8] c"echo \22barplot(y, names.arg=z, main=NULL, ylab=\\\22Frequency\\\22)\22 >> graphs.R\00"
@.str.23 = [45 x i8] c"echo \22w<-scan(\\\22length.stats\\\22)\22 >> graphs.R\00"
@.str.24 = [81 x i8] c"echo \22hist(log(w), main=NULL, xlab=\\\22log(coverage island length)\\\22)\22 >> graphs.R\00"
@.str.25 = [46 x i8] c"echo \22t<-scan(\\\22libsize.stats\\\22)\22 >> graphs.R\00"
@.str.26 = [74 x i8] c"echo \22boxplot(log(t), main=NULL, ylab=\\\22log(library size)\\\22)\22 >> graphs.R\00"
@.str.27 = [29 x i8] c"echo \22dev.off()\22 >> graphs.R\00"
@.str.28 = [21 x i8] c"R CMD BATCH graphs.R\00"
@.str.29 = [21 x i8] c"mv Rplots.pdf %s.pdf\00"
@.str.30 = [12 x i8] c"rm graphs.R\00"
@.str.31 = [10 x i8] c"rm *stats\00"
@.str.32 = [10 x i8] c"rm *.Rout\00"
@.str.33 = [12 x i8] c"rm *.pileup\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 i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca [1000 x i8]
%12 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %7
store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i8** %8
store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0), i8** %9
br label %13
13: ; preds = %26, %2
%14 = load i32, i32* %4
%15 = load i8**, i8*** %5
%16 = call i32 @getopt(i32 %14, i8** %15, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0))
store i32 %16, i32* %6
%17 = icmp ne i32 %16, -1
br i1 %17, label %18, label %27
18: ; preds = %13
%19 = load i32, i32* %6
switch i32 %19, label %26 [
i32 100, label %20
i32 105, label %22
i32 103, label %24
]
20: ; preds = %18
%21 = load i8*, i8** @optarg
store i8* %21, i8** %8
br label %26
22: ; preds = %18
%23 = load i8*, i8** @optarg
store i8* %23, i8** %9
br label %26
24: ; preds = %18
%25 = load i8*, i8** @optarg
store i8* %25, i8** %10
br label %26
26: ; preds = %18, %24, %22, %20
br label %13
27: ; preds = %13
%28 = load i8*, i8** %8
%29 = call i64 @strcmp(i8* %28, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0))
%30 = icmp eq i64 %29, 0
br i1 %30, label %31, label %33
31: ; preds = %27
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.4, i64 0, i64 0))
br label %36
33: ; preds = %27
%34 = load i8*, i8** %8
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.5, i64 0, i64 0), i8* %34)
br label %36
36: ; preds = %33, %31
%37 = load i8**, i8*** %5
%38 = load i32, i32* @optind
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8*, i8** %37, i64 %39
%41 = load i8*, i8** %40
%42 = load i8*, i8** %8
%43 = call i32 @atoi(i8* %42)
%44 = call i32 @get_coverage(i8* %41, i32 %43)
%45 = load i8**, i8*** %5
%46 = load i32, i32* @optind
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8*, i8** %45, i64 %47
%49 = load i8*, i8** %48
%50 = load i8*, i8** %9
%51 = call i32 @atoi(i8* %50)
%52 = load i8*, i8** %8
%53 = call i32 @atoi(i8* %52)
%54 = call i32 @get_intervals(i8* %49, i32 %51, i32 %53)
%55 = load i8**, i8*** %5
%56 = load i32, i32* @optind
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8*, i8** %55, i64 %57
%59 = load i8*, i8** %58
%60 = load i8*, i8** %10
%61 = call i32 @get_annotation(i8* %59, i8* %60)
%62 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%63 = load i8**, i8*** %5
%64 = load i32, i32* @optind
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8*, i8** %63, i64 %65
%67 = load i8*, i8** %66
%68 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %62, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i8* %67)
%69 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%70 = call i32 @system(i8* %69)
store i32 %70, i32* %12
%71 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%72 = load i8**, i8*** %5
%73 = load i32, i32* @optind
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8*, i8** %72, i64 %74
%76 = load i8*, i8** %75
%77 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %71, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.7, i64 0, i64 0), i8* %76)
%78 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%79 = call i32 @system(i8* %78)
store i32 %79, i32* %12
%80 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%81 = load i8**, i8*** %5
%82 = load i32, i32* @optind
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i8*, i8** %81, i64 %83
%85 = load i8*, i8** %84
%86 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %80, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.8, i64 0, i64 0), i8* %85)
%87 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%88 = call i32 @system(i8* %87)
store i32 %88, i32* %12
%89 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%90 = load i8**, i8*** %5
%91 = load i32, i32* @optind
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8*, i8** %90, i64 %92
%94 = load i8*, i8** %93
%95 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %89, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.9, i64 0, i64 0), i8* %94)
%96 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%97 = call i32 @system(i8* %96)
store i32 %97, i32* %12
%98 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%99 = load i8**, i8*** %5
%100 = load i32, i32* @optind
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8*, i8** %99, i64 %101
%103 = load i8*, i8** %102
%104 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %98, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.10, i64 0, i64 0), i8* %103)
%105 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%106 = call i32 @system(i8* %105)
store i32 %106, i32* %12
%107 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%108 = load i8**, i8*** %5
%109 = load i32, i32* @optind
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8*, i8** %108, i64 %110
%112 = load i8*, i8** %111
%113 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %107, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.11, i64 0, i64 0), i8* %112)
%114 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%115 = call i32 @system(i8* %114)
store i32 %115, i32* %12
%116 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%117 = load i8**, i8*** %5
%118 = load i32, i32* @optind
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8*, i8** %117, i64 %119
%121 = load i8*, i8** %120
%122 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %116, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0), i8* %121)
%123 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%124 = call i32 @system(i8* %123)
store i32 %124, i32* %12
%125 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%126 = load i8**, i8*** %5
%127 = load i32, i32* @optind
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8*, i8** %126, i64 %128
%130 = load i8*, i8** %129
%131 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %125, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.13, i64 0, i64 0), i8* %130)
%132 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%133 = call i32 @system(i8* %132)
store i32 %133, i32* %12
%134 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%135 = load i8**, i8*** %5
%136 = load i32, i32* @optind
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i8*, i8** %135, i64 %137
%139 = load i8*, i8** %138
%140 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %134, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.14, i64 0, i64 0), i8* %139)
%141 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%142 = call i32 @system(i8* %141)
store i32 %142, i32* %12
%143 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%144 = load i8**, i8*** %5
%145 = load i32, i32* @optind
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8*, i8** %144, i64 %146
%148 = load i8*, i8** %147
%149 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %143, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0), i8* %148)
%150 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%151 = call i32 @system(i8* %150)
store i32 %151, i32* %12
%152 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%153 = load i8**, i8*** %5
%154 = load i32, i32* @optind
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i8*, i8** %153, i64 %155
%157 = load i8*, i8** %156
%158 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %152, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8* %157)
%159 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%160 = call i32 @system(i8* %159)
store i32 %160, i32* %12
%161 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%162 = load i8**, i8*** %5
%163 = load i32, i32* @optind
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i8*, i8** %162, i64 %164
%166 = load i8*, i8** %165
%167 = load i8**, i8*** %5
%168 = load i32, i32* @optind
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8*, i8** %167, i64 %169
%171 = load i8*, i8** %170
%172 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %161, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.17, i64 0, i64 0), i8* %166, i8* %171)
%173 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%174 = call i32 @system(i8* %173)
store i32 %174, i32* %12
%175 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%176 = load i8**, i8*** %5
%177 = load i32, i32* @optind
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i8*, i8** %176, i64 %178
%180 = load i8*, i8** %179
%181 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %175, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.18, i64 0, i64 0), i8* %180)
%182 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%183 = call i32 @system(i8* %182)
store i32 %183, i32* %12
%184 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%185 = load i8**, i8*** %5
%186 = load i32, i32* @optind
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8*, i8** %185, i64 %187
%189 = load i8*, i8** %188
%190 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %184, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.19, i64 0, i64 0), i8* %189)
%191 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%192 = call i32 @system(i8* %191)
store i32 %192, i32* %12
%193 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%194 = load i8**, i8*** %5
%195 = load i32, i32* @optind
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i8*, i8** %194, i64 %196
%198 = load i8*, i8** %197
%199 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %193, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.20, i64 0, i64 0), i8* %198)
%200 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%201 = call i32 @system(i8* %200)
store i32 %201, i32* %12
%202 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%203 = load i8**, i8*** %5
%204 = load i32, i32* @optind
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8*, i8** %203, i64 %205
%207 = load i8*, i8** %206
%208 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %202, i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.21, i64 0, i64 0), i8* %207)
%209 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%210 = call i32 @system(i8* %209)
store i32 %210, i32* %12
%211 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%212 = load i8**, i8*** %5
%213 = load i32, i32* @optind
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i8*, i8** %212, i64 %214
%216 = load i8*, i8** %215
%217 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %211, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.22, i64 0, i64 0), i8* %216)
%218 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%219 = call i32 @system(i8* %218)
store i32 %219, i32* %12
%220 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%221 = load i8**, i8*** %5
%222 = load i32, i32* @optind
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8*, i8** %221, i64 %223
%225 = load i8*, i8** %224
%226 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %220, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.23, i64 0, i64 0), i8* %225)
%227 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%228 = call i32 @system(i8* %227)
store i32 %228, i32* %12
%229 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%230 = load i8**, i8*** %5
%231 = load i32, i32* @optind
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8*, i8** %230, i64 %232
%234 = load i8*, i8** %233
%235 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %229, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.24, i64 0, i64 0), i8* %234)
%236 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%237 = call i32 @system(i8* %236)
store i32 %237, i32* %12
%238 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%239 = load i8**, i8*** %5
%240 = load i32, i32* @optind
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i8*, i8** %239, i64 %241
%243 = load i8*, i8** %242
%244 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %238, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.25, i64 0, i64 0), i8* %243)
%245 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%246 = call i32 @system(i8* %245)
store i32 %246, i32* %12
%247 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%248 = load i8**, i8*** %5
%249 = load i32, i32* @optind
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i8*, i8** %248, i64 %250
%252 = load i8*, i8** %251
%253 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %247, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.26, i64 0, i64 0), i8* %252)
%254 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%255 = call i32 @system(i8* %254)
store i32 %255, i32* %12
%256 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%257 = load i8**, i8*** %5
%258 = load i32, i32* @optind
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8*, i8** %257, i64 %259
%261 = load i8*, i8** %260
%262 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %256, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.27, i64 0, i64 0), i8* %261)
%263 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%264 = call i32 @system(i8* %263)
store i32 %264, i32* %12
%265 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%266 = load i8**, i8*** %5
%267 = load i32, i32* @optind
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i8*, i8** %266, i64 %268
%270 = load i8*, i8** %269
%271 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %265, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.28, i64 0, i64 0), i8* %270)
%272 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%273 = call i32 @system(i8* %272)
store i32 %273, i32* %12
%274 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%275 = load i8**, i8*** %5
%276 = load i32, i32* @optind
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i8*, i8** %275, i64 %277
%279 = load i8*, i8** %278
%280 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %274, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.29, i64 0, i64 0), i8* %279)
%281 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%282 = call i32 @system(i8* %281)
store i32 %282, i32* %12
%283 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%284 = load i8**, i8*** %5
%285 = load i32, i32* @optind
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i8*, i8** %284, i64 %286
%288 = load i8*, i8** %287
%289 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %283, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.30, i64 0, i64 0), i8* %288)
%290 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%291 = call i32 @system(i8* %290)
store i32 %291, i32* %12
%292 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%293 = load i8**, i8*** %5
%294 = load i32, i32* @optind
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i8*, i8** %293, i64 %295
%297 = load i8*, i8** %296
%298 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %292, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.31, i64 0, i64 0), i8* %297)
%299 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%300 = call i32 @system(i8* %299)
store i32 %300, i32* %12
%301 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%302 = load i8**, i8*** %5
%303 = load i32, i32* @optind
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i8*, i8** %302, i64 %304
%306 = load i8*, i8** %305
%307 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %301, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.32, i64 0, i64 0), i8* %306)
%308 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%309 = call i32 @system(i8* %308)
store i32 %309, i32* %12
%310 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%311 = load i8**, i8*** %5
%312 = load i32, i32* @optind
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i8*, i8** %311, i64 %313
%315 = load i8*, i8** %314
%316 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %310, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.33, i64 0, i64 0), i8* %315)
%317 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%318 = call i32 @system(i8* %317)
store i32 %318, i32* %12
%319 = load i32, i32* %3
ret i32 %319
}

LLVM IR (-O2):
@.str = [14 x i8] c"default_depth\00"
@.str.1 = [26 x i8] c"default_interval_distance\00"
@.str.2 = [7 x i8] c"d:i:g:\00"
@optarg = external global i8*
@.str.3 = [17 x i8] c"default_distance\00"
@.str.5 = [20 x i8] c"depth input was %s\0A\00"
@optind = external global i32
@.str.6 = [36 x i8] c"cut -f5 %s.tmp3 > percentages.stats\00"
@.str.7 = [56 x i8] c"grep protein_coding %s.tmp3 | wc -l >> annotation.stats\00"
@.str.8 = [49 x i8] c"grep lincRNA %s.tmp3 | wc -l >> annotation.stats\00"
@.str.9 = [45 x i8] c"grep miR %s.tmp3 | wc -l >> annotation.stats\00"
@.str.10 = [51 x i8] c"grep antisense %s.tmp3 | wc -l >> annotation.stats\00"
@.str.11 = [52 x i8] c"grep pseudogene %s.tmp3 | wc -l >> annotation.stats\00"
@.str.12 = [31 x i8] c"cut -f6 %s.tmp2 > length.stats\00"
@.str.13 = [32 x i8] c"cut -f7 %s.tmp2 > libsize.stats\00"
@.str.14 = [11 x i8] c"rm %s.tmp2\00"
@.str.15 = [10 x i8] c"rm %s.tmp\00"
@.str.16 = [11 x i8] c"rm tmp.gtf\00"
@.str.17 = [22 x i8] c"mv %s.tmp3 %s.results\00"
@.str.18 = [49 x i8] c"echo \22x<-scan(\\\22percentages.stats\\\22)\22 > graphs.R\00"
@.str.19 = [59 x i8] c"echo \22hist(x, main=NULL, xlab=\\\22Percentage\\\22)\22 >> graphs.R\00"
@.str.20 = [49 x i8] c"echo \22y<-scan(\\\22annotation.stats\\\22)\22 >> graphs.R\00"
@.str.21 = [97 x i8] c"echo \22z<-c(\\\22protein_coding\\\22, \\\22lincRNA\\\22, \\\22miR\\\22, \\\22antisense\\\22, \\\22pseudogene\\\22)\22 >> graphs.R\00"
@.str.22 = [74 x i8] c"echo \22barplot(y, names.arg=z, main=NULL, ylab=\\\22Frequency\\\22)\22 >> graphs.R\00"
@.str.23 = [45 x i8] c"echo \22w<-scan(\\\22length.stats\\\22)\22 >> graphs.R\00"
@.str.24 = [81 x i8] c"echo \22hist(log(w), main=NULL, xlab=\\\22log(coverage island length)\\\22)\22 >> graphs.R\00"
@.str.25 = [46 x i8] c"echo \22t<-scan(\\\22libsize.stats\\\22)\22 >> graphs.R\00"
@.str.26 = [74 x i8] c"echo \22boxplot(log(t), main=NULL, ylab=\\\22log(library size)\\\22)\22 >> graphs.R\00"
@.str.27 = [29 x i8] c"echo \22dev.off()\22 >> graphs.R\00"
@.str.28 = [21 x i8] c"R CMD BATCH graphs.R\00"
@.str.29 = [21 x i8] c"mv Rplots.pdf %s.pdf\00"
@.str.30 = [12 x i8] c"rm graphs.R\00"
@.str.31 = [10 x i8] c"rm *stats\00"
@.str.32 = [10 x i8] c"rm *.Rout\00"
@.str.33 = [12 x i8] c"rm *.pileup\00"
@str = [44 x i8] c"no parameter was specified so default to 20\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca [1000 x i8]
%4 = getelementptr inbounds [1000 x i8], [1000 x i8]* %3, i64 0, i64 0
br label %5
5: ; preds = %18, %2
%6 = phi i8* [ %19, %18 ], [ getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0), %2 ]
%7 = phi i8* [ %10, %18 ], [ undef, %2 ]
%8 = phi i8* [ %13, %18 ], [ getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), %2 ]
br label %9
9: ; preds = %5, %20
%10 = phi i8* [ %7, %5 ], [ %21, %20 ]
%11 = phi i8* [ %8, %5 ], [ %13, %20 ]
br label %12
12: ; preds = %9, %16
%13 = phi i8* [ %11, %9 ], [ %17, %16 ]
br label %14
14: ; preds = %12, %14
%15 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0))
switch i32 %15, label %14 [
i32 -1, label %22
i32 100, label %16
i32 105, label %18
i32 103, label %20
]
16: ; preds = %14
%17 = load i8*, i8** @optarg
br label %12
18: ; preds = %14
%19 = load i8*, i8** @optarg
br label %5
20: ; preds = %14
%21 = load i8*, i8** @optarg
br label %9
22: ; preds = %14
%23 = tail call i64 @strcmp(i8* %13, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0))
%24 = icmp eq i64 %23, 0
br i1 %24, label %25, label %27
25: ; preds = %22
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @str, i64 0, i64 0))
br label %29
27: ; preds = %22
%28 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.5, i64 0, i64 0), i8* %13)
br label %29
29: ; preds = %27, %25
%30 = load i32, i32* @optind
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8*, i8** %1, i64 %31
%33 = load i8*, i8** %32
%34 = tail call i32 @atoi(i8* %13)
%35 = tail call i32 @get_coverage(i8* %33, i32 %34)
%36 = load i32, i32* @optind
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8*, i8** %1, i64 %37
%39 = load i8*, i8** %38
%40 = tail call i32 @atoi(i8* %6)
%41 = tail call i32 @atoi(i8* %13)
%42 = tail call i32 @get_intervals(i8* %39, i32 %40, i32 %41)
%43 = load i32, i32* @optind
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8*, i8** %1, i64 %44
%46 = load i8*, i8** %45
%47 = tail call i32 @get_annotation(i8* %46, i8* %10)
%48 = load i32, i32* @optind
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8*, i8** %1, i64 %49
%51 = load i8*, i8** %50
%52 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i8* %51)
%53 = call i32 @system(i8* %4)
%54 = load i32, i32* @optind
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8*, i8** %1, i64 %55
%57 = load i8*, i8** %56
%58 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.7, i64 0, i64 0), i8* %57)
%59 = call i32 @system(i8* %4)
%60 = load i32, i32* @optind
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8*, i8** %1, i64 %61
%63 = load i8*, i8** %62
%64 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.8, i64 0, i64 0), i8* %63)
%65 = call i32 @system(i8* %4)
%66 = load i32, i32* @optind
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8*, i8** %1, i64 %67
%69 = load i8*, i8** %68
%70 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.9, i64 0, i64 0), i8* %69)
%71 = call i32 @system(i8* %4)
%72 = load i32, i32* @optind
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8*, i8** %1, i64 %73
%75 = load i8*, i8** %74
%76 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.10, i64 0, i64 0), i8* %75)
%77 = call i32 @system(i8* %4)
%78 = load i32, i32* @optind
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i8*, i8** %1, i64 %79
%81 = load i8*, i8** %80
%82 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.11, i64 0, i64 0), i8* %81)
%83 = call i32 @system(i8* %4)
%84 = load i32, i32* @optind
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8*, i8** %1, i64 %85
%87 = load i8*, i8** %86
%88 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0), i8* %87)
%89 = call i32 @system(i8* %4)
%90 = load i32, i32* @optind
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8*, i8** %1, i64 %91
%93 = load i8*, i8** %92
%94 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.13, i64 0, i64 0), i8* %93)
%95 = call i32 @system(i8* %4)
%96 = load i32, i32* @optind
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i8*, i8** %1, i64 %97
%99 = load i8*, i8** %98
%100 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.14, i64 0, i64 0), i8* %99)
%101 = call i32 @system(i8* %4)
%102 = load i32, i32* @optind
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i8*, i8** %1, i64 %103
%105 = load i8*, i8** %104
%106 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.15, i64 0, i64 0), i8* %105)
%107 = call i32 @system(i8* %4)
%108 = load i32, i32* @optind
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8*, i8** %1, i64 %109
%111 = load i8*, i8** %110
%112 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8* %111)
%113 = call i32 @system(i8* %4)
%114 = load i32, i32* @optind
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8*, i8** %1, i64 %115
%117 = load i8*, i8** %116
%118 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.17, i64 0, i64 0), i8* %117, i8* %117)
%119 = call i32 @system(i8* %4)
%120 = load i32, i32* @optind
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8*, i8** %1, i64 %121
%123 = load i8*, i8** %122
%124 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.18, i64 0, i64 0), i8* %123)
%125 = call i32 @system(i8* %4)
%126 = load i32, i32* @optind
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8*, i8** %1, i64 %127
%129 = load i8*, i8** %128
%130 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.19, i64 0, i64 0), i8* %129)
%131 = call i32 @system(i8* %4)
%132 = load i32, i32* @optind
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8*, i8** %1, i64 %133
%135 = load i8*, i8** %134
%136 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.20, i64 0, i64 0), i8* %135)
%137 = call i32 @system(i8* %4)
%138 = load i32, i32* @optind
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8*, i8** %1, i64 %139
%141 = load i8*, i8** %140
%142 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @.str.21, i64 0, i64 0), i8* %141)
%143 = call i32 @system(i8* %4)
%144 = load i32, i32* @optind
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8*, i8** %1, i64 %145
%147 = load i8*, i8** %146
%148 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.22, i64 0, i64 0), i8* %147)
%149 = call i32 @system(i8* %4)
%150 = load i32, i32* @optind
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8*, i8** %1, i64 %151
%153 = load i8*, i8** %152
%154 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.23, i64 0, i64 0), i8* %153)
%155 = call i32 @system(i8* %4)
%156 = load i32, i32* @optind
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8*, i8** %1, i64 %157
%159 = load i8*, i8** %158
%160 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @.str.24, i64 0, i64 0), i8* %159)
%161 = call i32 @system(i8* %4)
%162 = load i32, i32* @optind
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8*, i8** %1, i64 %163
%165 = load i8*, i8** %164
%166 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.25, i64 0, i64 0), i8* %165)
%167 = call i32 @system(i8* %4)
%168 = load i32, i32* @optind
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8*, i8** %1, i64 %169
%171 = load i8*, i8** %170
%172 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.26, i64 0, i64 0), i8* %171)
%173 = call i32 @system(i8* %4)
%174 = load i32, i32* @optind
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8*, i8** %1, i64 %175
%177 = load i8*, i8** %176
%178 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.27, i64 0, i64 0), i8* %177)
%179 = call i32 @system(i8* %4)
%180 = load i32, i32* @optind
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8*, i8** %1, i64 %181
%183 = load i8*, i8** %182
%184 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.28, i64 0, i64 0), i8* %183)
%185 = call i32 @system(i8* %4)
%186 = load i32, i32* @optind
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8*, i8** %1, i64 %187
%189 = load i8*, i8** %188
%190 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.29, i64 0, i64 0), i8* %189)
%191 = call i32 @system(i8* %4)
%192 = load i32, i32* @optind
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8*, i8** %1, i64 %193
%195 = load i8*, i8** %194
%196 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.30, i64 0, i64 0), i8* %195)
%197 = call i32 @system(i8* %4)
%198 = load i32, i32* @optind
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8*, i8** %1, i64 %199
%201 = load i8*, i8** %200
%202 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.31, i64 0, i64 0), i8* %201)
%203 = call i32 @system(i8* %4)
%204 = load i32, i32* @optind
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8*, i8** %1, i64 %205
%207 = load i8*, i8** %206
%208 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.32, i64 0, i64 0), i8* %207)
%209 = call i32 @system(i8* %4)
%210 = load i32, i32* @optind
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8*, i8** %1, i64 %211
%213 = load i8*, i8** %212
%214 = call i32 (i8*, i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.33, i64 0, i64 0), i8* %213)
%215 = call i32 @system(i8* %4)
ret i32 0
}