#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 */
char *RemoveLeadingZeroes(char *);
int /*<<< orphan*/ assert(int);
long atol(char *);
int /*<<< orphan*/ exit_wrapper(int);
int /*<<< orphan*/ free(char *);
scalar_t__ isdigit(char);
scalar_t__ isspace(char);
int /*<<< orphan*/ printf(char *, char *);
int /*<<< orphan*/ puts(char *);
unsigned long ConvertSRTTimestamp(char **ptr, int *errorstatus) {
  char *temp = NULL;
  unsigned int ctr = 1;
  char failed = 0;
  char hours[3 + 1] = {0};
  char minutes[3 + 1] = {0};
  char seconds[3 + 1] = {0};
  char millis[3 + 1] = {0};
  unsigned int index = 0;
  unsigned long sum = 0;
  long conversion = 0;
  if (ptr == NULL)
    failed = 1;
  else {
    temp = *ptr;
    if (temp == NULL)
      failed = 1;
  }
  if ((temp != NULL) && !isdigit(temp[0]))
    failed = 1;
  index = 0;
  while (!failed) {
    (assert(temp != NULL));
    if ((temp[ctr] == '\0') || (!isdigit(temp[ctr]) && (temp[ctr] != ':')))
      failed = 1;
    else {
      if (isdigit(temp[ctr])) {
        if (index > 3)
          failed = 2;
        else
          hours[index++] = temp[ctr++];
      } else {
        ctr++;
        break;
      }
    }
  }
  (assert(index < 3 + 1));
  hours[index] = '\0';
  index = 0;
  while (!failed) {
    (assert(temp != NULL));
    if ((temp[ctr] == '\0') || (!isdigit(temp[ctr]) && (temp[ctr] != ':')))
      failed = 1;
    else {
      if (isdigit(temp[ctr])) {
        if (index > 3)
          failed = 2;
        else
          minutes[index++] = temp[ctr++];
      } else {
        ctr++;
        break;
      }
    }
  }
  (assert(index < 3 + 1));
  minutes[index] = '\0';
  index = 0;
  while (!failed) {
    (assert(temp != NULL));
    if ((temp[ctr] == '\0') || (!isdigit(temp[ctr]) && (temp[ctr] != ',')))
      failed = 1;
    else {
      if (isdigit(temp[ctr])) {
        if (index > 3)
          failed = 2;
        else
          seconds[index++] = temp[ctr++];
      } else {
        ctr++;
        break;
      }
    }
  }
  (assert(index < 3 + 1));
  seconds[index] = '\0';
  index = 0;
  while (!failed) {
    (assert(temp != NULL));
    if ((temp[ctr] == '\0') || !isdigit(temp[ctr])) {
      if (isspace(temp[ctr]) || (temp[ctr] == '\0'))
        break;
      else
        failed = 1;
    } else {
      if (index > 3)
        failed = 2;
      else
        millis[index++] = temp[ctr++];
    }
  }
  (assert(index < 3 + 1));
  millis[index] = '\0';
  if (failed) {
    printf("Error: Invalid timestamp \"%s\"\n", temp);
    if (errorstatus != NULL) {
      *errorstatus = 1;
      return 0;
    } else {
      (void)puts("Aborting");
      exit_wrapper(1);
    }
  }
  (assert((ptr != NULL) && (temp != NULL)));
  *ptr = &(temp[ctr + 1]);
  temp = RemoveLeadingZeroes(hours);
  if (temp[0] != '0') {
    conversion = atol(temp);
    if (conversion < 1) {
      (void)puts("Error converting string to integer\nAborting");
      free(temp);
      if (errorstatus != NULL) {
        *errorstatus = 2;
        return 0;
      } else
        exit_wrapper(2);
    }
    sum += conversion * 3600000;
  }
  free(temp);
  temp = RemoveLeadingZeroes(minutes);
  if (temp[0] != '0') {
    conversion = atol(temp);
    if (conversion < 1) {
      (void)puts("Error converting string to integer\nAborting");
      free(temp);
      if (errorstatus != NULL) {
        *errorstatus = 2;
        return 0;
      } else
        exit_wrapper(2);
    }
    sum += conversion * 60000;
  }
  free(temp);
  temp = RemoveLeadingZeroes(seconds);
  if (temp[0] != '0') {
    conversion = atol(temp);
    if (conversion < 1) {
      (void)puts("Error converting string to integer\nAborting");
      free(temp);
      if (errorstatus != NULL) {
        *errorstatus = 3;
        return 0;
      } else
        exit_wrapper(3);
    }
    sum += conversion * 1000;
  }
  free(temp);
  temp = RemoveLeadingZeroes(millis);
  if (temp[0] != '0') {
    conversion = atol(temp);
    if (conversion < 1) {
      (void)puts("Error converting string to integer\nAborting");
      free(temp);
      if (errorstatus != NULL) {
        *errorstatus = 4;
        return 0;
      } else
        exit_wrapper(4);
    }
    sum += conversion;
  }
  free(temp);
  return sum;
}


x86 assembly (clang, -O0):
<ConvertSRTTimestamp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
movb   $0x0,-0x25(%rbp)
lea    -0x29(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1070 <memset@plt>
lea    -0x2d(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1070 <memset@plt>
lea    -0x31(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1070 <memset@plt>
lea    -0x35(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1070 <memset@plt>
movl   $0x0,-0x3c(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    122e <ConvertSRTTimestamp+0x8e>
movb   $0x1,-0x25(%rbp)
jmp    124d <ConvertSRTTimestamp+0xad>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    1248 <ConvertSRTTimestamp+0xa8>
movb   $0x1,-0x25(%rbp)
jmp    124d <ConvertSRTTimestamp+0xad>
cmpq   $0x0,-0x20(%rbp)
je     1272 <ConvertSRTTimestamp+0xd2>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
jne    1272 <ConvertSRTTimestamp+0xd2>
movb   $0x1,-0x25(%rbp)
movl   $0x0,-0x3c(%rbp)
cmpb   $0x0,-0x25(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    128f <ConvertSRTTimestamp+0xef>
jmp    135b <ConvertSRTTimestamp+0x1bb>
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     12e3 <ConvertSRTTimestamp+0x143>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
jne    12ec <ConvertSRTTimestamp+0x14c>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
je     12ec <ConvertSRTTimestamp+0x14c>
movb   $0x1,-0x25(%rbp)
jmp    1356 <ConvertSRTTimestamp+0x1b6>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1343 <ConvertSRTTimestamp+0x1a3>
cmpl   $0x3,-0x3c(%rbp)
jbe    1319 <ConvertSRTTimestamp+0x179>
movb   $0x2,-0x25(%rbp)
jmp    133e <ConvertSRTTimestamp+0x19e>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x3c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
mov    %eax,%eax
mov    %cl,-0x29(%rbp,%rax,1)
jmp    1351 <ConvertSRTTimestamp+0x1b1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    135b <ConvertSRTTimestamp+0x1bb>
jmp    1356 <ConvertSRTTimestamp+0x1b6>
jmp    1279 <ConvertSRTTimestamp+0xd9>
cmpl   $0x4,-0x3c(%rbp)
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x3c(%rbp),%eax
movb   $0x0,-0x29(%rbp,%rax,1)
movl   $0x0,-0x3c(%rbp)
cmpb   $0x0,-0x25(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1391 <ConvertSRTTimestamp+0x1f1>
jmp    145d <ConvertSRTTimestamp+0x2bd>
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     13e5 <ConvertSRTTimestamp+0x245>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
jne    13ee <ConvertSRTTimestamp+0x24e>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
je     13ee <ConvertSRTTimestamp+0x24e>
movb   $0x1,-0x25(%rbp)
jmp    1458 <ConvertSRTTimestamp+0x2b8>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1445 <ConvertSRTTimestamp+0x2a5>
cmpl   $0x3,-0x3c(%rbp)
jbe    141b <ConvertSRTTimestamp+0x27b>
movb   $0x2,-0x25(%rbp)
jmp    1440 <ConvertSRTTimestamp+0x2a0>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x3c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
mov    %eax,%eax
mov    %cl,-0x2d(%rbp,%rax,1)
jmp    1453 <ConvertSRTTimestamp+0x2b3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    145d <ConvertSRTTimestamp+0x2bd>
jmp    1458 <ConvertSRTTimestamp+0x2b8>
jmp    137b <ConvertSRTTimestamp+0x1db>
cmpl   $0x4,-0x3c(%rbp)
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x3c(%rbp),%eax
movb   $0x0,-0x2d(%rbp,%rax,1)
movl   $0x0,-0x3c(%rbp)
cmpb   $0x0,-0x25(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1493 <ConvertSRTTimestamp+0x2f3>
jmp    155f <ConvertSRTTimestamp+0x3bf>
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     14e7 <ConvertSRTTimestamp+0x347>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
jne    14f0 <ConvertSRTTimestamp+0x350>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
je     14f0 <ConvertSRTTimestamp+0x350>
movb   $0x1,-0x25(%rbp)
jmp    155a <ConvertSRTTimestamp+0x3ba>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1547 <ConvertSRTTimestamp+0x3a7>
cmpl   $0x3,-0x3c(%rbp)
jbe    151d <ConvertSRTTimestamp+0x37d>
movb   $0x2,-0x25(%rbp)
jmp    1542 <ConvertSRTTimestamp+0x3a2>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x3c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
mov    %eax,%eax
mov    %cl,-0x31(%rbp,%rax,1)
jmp    1555 <ConvertSRTTimestamp+0x3b5>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    155f <ConvertSRTTimestamp+0x3bf>
jmp    155a <ConvertSRTTimestamp+0x3ba>
jmp    147d <ConvertSRTTimestamp+0x2dd>
cmpl   $0x4,-0x3c(%rbp)
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x3c(%rbp),%eax
movb   $0x0,-0x31(%rbp,%rax,1)
movl   $0x0,-0x3c(%rbp)
cmpb   $0x0,-0x25(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1595 <ConvertSRTTimestamp+0x3f5>
jmp    1653 <ConvertSRTTimestamp+0x4b3>
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     15d5 <ConvertSRTTimestamp+0x435>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
jne    1611 <ConvertSRTTimestamp+0x471>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1090 <isspace@plt>
cmp    $0x0,%rax
jne    1603 <ConvertSRTTimestamp+0x463>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1608 <ConvertSRTTimestamp+0x468>
jmp    1653 <ConvertSRTTimestamp+0x4b3>
movb   $0x1,-0x25(%rbp)
jmp    164e <ConvertSRTTimestamp+0x4ae>
cmpl   $0x3,-0x3c(%rbp)
jbe    1624 <ConvertSRTTimestamp+0x484>
movb   $0x2,-0x25(%rbp)
jmp    1649 <ConvertSRTTimestamp+0x4a9>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x3c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
mov    %eax,%eax
mov    %cl,-0x35(%rbp,%rax,1)
jmp    164e <ConvertSRTTimestamp+0x4ae>
jmp    157f <ConvertSRTTimestamp+0x3df>
cmpl   $0x4,-0x3c(%rbp)
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x3c(%rbp),%eax
movb   $0x0,-0x35(%rbp,%rax,1)
cmpb   $0x0,-0x25(%rbp)
je     16c3 <ConvertSRTTimestamp+0x523>
mov    -0x20(%rbp),%rsi
lea    0x97f(%rip),%rdi
call   1060 <printf@plt>
cmpq   $0x0,-0x18(%rbp)
je     16a8 <ConvertSRTTimestamp+0x508>
mov    -0x18(%rbp),%rax
movl   $0x1,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    1955 <ConvertSRTTimestamp+0x7b5>
lea    0x993(%rip),%rdi
call   1050 <puts@plt>
mov    $0x1,%edi
call   1080 <exit_wrapper@plt>
jmp    16c3 <ConvertSRTTimestamp+0x523>
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x51(%rbp)
je     16de <ConvertSRTTimestamp+0x53e>
cmpq   $0x0,-0x20(%rbp)
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   10a0 <assert@plt>
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
lea    -0x29(%rbp),%rdi
call   10c0 <RemoveLeadingZeroes@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
je     178c <ConvertSRTTimestamp+0x5ec>
mov    -0x20(%rbp),%rdi
call   10b0 <atol@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x1,-0x50(%rbp)
jge    177c <ConvertSRTTimestamp+0x5dc>
lea    0x8e2(%rip),%rdi
call   1050 <puts@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x18(%rbp)
je     176d <ConvertSRTTimestamp+0x5cd>
mov    -0x18(%rbp),%rax
movl   $0x2,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    1955 <ConvertSRTTimestamp+0x7b5>
mov    $0x2,%edi
call   1080 <exit_wrapper@plt>
jmp    177c <ConvertSRTTimestamp+0x5dc>
imul   $0x36ee80,-0x50(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
lea    -0x2d(%rbp),%rdi
call   10c0 <RemoveLeadingZeroes@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
je     1820 <ConvertSRTTimestamp+0x680>
mov    -0x20(%rbp),%rdi
call   10b0 <atol@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x1,-0x50(%rbp)
jge    1810 <ConvertSRTTimestamp+0x670>
lea    0x84e(%rip),%rdi
call   1050 <puts@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x18(%rbp)
je     1801 <ConvertSRTTimestamp+0x661>
mov    -0x18(%rbp),%rax
movl   $0x2,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    1955 <ConvertSRTTimestamp+0x7b5>
mov    $0x2,%edi
call   1080 <exit_wrapper@plt>
jmp    1810 <ConvertSRTTimestamp+0x670>
imul   $0xea60,-0x50(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
lea    -0x31(%rbp),%rdi
call   10c0 <RemoveLeadingZeroes@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
je     18b4 <ConvertSRTTimestamp+0x714>
mov    -0x20(%rbp),%rdi
call   10b0 <atol@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x1,-0x50(%rbp)
jge    18a4 <ConvertSRTTimestamp+0x704>
lea    0x7ba(%rip),%rdi
call   1050 <puts@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x18(%rbp)
je     1895 <ConvertSRTTimestamp+0x6f5>
mov    -0x18(%rbp),%rax
movl   $0x3,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    1955 <ConvertSRTTimestamp+0x7b5>
mov    $0x3,%edi
call   1080 <exit_wrapper@plt>
jmp    18a4 <ConvertSRTTimestamp+0x704>
imul   $0x3e8,-0x50(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
lea    -0x35(%rbp),%rdi
call   10c0 <RemoveLeadingZeroes@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
je     1944 <ConvertSRTTimestamp+0x7a4>
mov    -0x20(%rbp),%rdi
call   10b0 <atol@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x1,-0x50(%rbp)
jge    1938 <ConvertSRTTimestamp+0x798>
lea    0x726(%rip),%rdi
call   1050 <puts@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x18(%rbp)
je     1929 <ConvertSRTTimestamp+0x789>
mov    -0x18(%rbp),%rax
movl   $0x4,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    1955 <ConvertSRTTimestamp+0x7b5>
mov    $0x4,%edi
call   1080 <exit_wrapper@plt>
jmp    1938 <ConvertSRTTimestamp+0x798>
mov    -0x50(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ConvertSRTTimestamp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,0x28(%rsp)
movl   $0x0,0x24(%rsp)
movl   $0x0,0x20(%rsp)
movl   $0x0,0x1c(%rsp)
movl   $0x0,0xc(%rsp)
mov    $0x1,%eax
mov    %rax,(%rsp)
xor    %r13d,%r13d
mov    $0x1,%bpl
test   %rdi,%rdi
mov    %rdi,0x30(%rsp)
je     13d1 <ConvertSRTTimestamp+0x241>
mov    %rdi,%rbx
mov    (%rdi),%r12
test   %r12,%r12
je     13d1 <ConvertSRTTimestamp+0x241>
movsbl (%r12),%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     13ee <ConvertSRTTimestamp+0x25e>
mov    $0x1,%edi
call   1090 <assert@plt>
mov    0x1(%r12),%al
test   %al,%al
je     13e5 <ConvertSRTTimestamp+0x255>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    0x1(%r12),%cl
test   %rax,%rax
jne    1236 <ConvertSRTTimestamp+0xa6>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1418 <ConvertSRTTimestamp+0x288>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     13ff <ConvertSRTTimestamp+0x26f>
mov    0x1(%r12),%al
mov    %al,0x24(%rsp)
mov    $0x1,%r14d
mov    $0x1,%edi
call   1090 <assert@plt>
mov    0x2(%r12),%al
mov    $0x2,%ecx
mov    %rcx,(%rsp)
mov    $0x1,%bl
test   %al,%al
je     1426 <ConvertSRTTimestamp+0x296>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    0x2(%r12),%cl
test   %rax,%rax
jne    1295 <ConvertSRTTimestamp+0x105>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1426 <ConvertSRTTimestamp+0x296>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1434 <ConvertSRTTimestamp+0x2a4>
mov    0x2(%r12),%al
mov    %al,0x25(%rsp)
mov    $0x1,%edi
call   1090 <assert@plt>
mov    0x3(%r12),%al
mov    $0x3,%ecx
mov    %rcx,(%rsp)
mov    $0x2,%r14d
mov    $0x1,%bl
test   %al,%al
je     1426 <ConvertSRTTimestamp+0x296>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    0x3(%r12),%cl
test   %rax,%rax
jne    12f4 <ConvertSRTTimestamp+0x164>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1426 <ConvertSRTTimestamp+0x296>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1445 <ConvertSRTTimestamp+0x2b5>
mov    0x3(%r12),%al
mov    %al,0x26(%rsp)
mov    $0x1,%edi
call   1090 <assert@plt>
mov    0x4(%r12),%al
mov    $0x4,%ecx
mov    %rcx,(%rsp)
mov    $0x3,%r14d
mov    $0x1,%bl
test   %al,%al
je     1426 <ConvertSRTTimestamp+0x296>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    0x4(%r12),%cl
test   %rax,%rax
jne    1353 <ConvertSRTTimestamp+0x1c3>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1426 <ConvertSRTTimestamp+0x296>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1456 <ConvertSRTTimestamp+0x2c6>
mov    0x4(%r12),%al
mov    %al,0x27(%rsp)
mov    $0x1,%edi
call   1090 <assert@plt>
mov    0x5(%r12),%al
mov    $0x5,%ecx
mov    %rcx,(%rsp)
mov    $0x4,%r14d
mov    $0x1,%bl
test   %al,%al
je     1426 <ConvertSRTTimestamp+0x296>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    0x5(%r12),%cl
test   %rax,%rax
jne    13ae <ConvertSRTTimestamp+0x21e>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1426 <ConvertSRTTimestamp+0x296>
movsbl %cl,%edi
call   1040 <isdigit@plt>
mov    $0x2,%bl
mov    $0x4,%r14d
test   %rax,%rax
jne    1426 <ConvertSRTTimestamp+0x296>
mov    $0x6,%eax
mov    %rax,(%rsp)
jmp    1465 <ConvertSRTTimestamp+0x2d5>
xor    %r12d,%r12d
xor    %eax,%eax
mov    %rax,0x10(%rsp)
xor    %ebx,%ebx
xor    %r14d,%r14d
jmp    1470 <ConvertSRTTimestamp+0x2e0>
mov    $0x1,%eax
mov    %rax,(%rsp)
xor    %ebx,%ebx
mov    $0x1,%al
mov    %rax,0x10(%rsp)
mov    $0x1,%bpl
xor    %r14d,%r14d
jmp    1470 <ConvertSRTTimestamp+0x2e0>
mov    $0x2,%eax
mov    %rax,(%rsp)
xor    %ebp,%ebp
mov    $0x1,%al
mov    %rax,0x10(%rsp)
mov    $0x1,%bl
xor    %r14d,%r14d
jmp    1470 <ConvertSRTTimestamp+0x2e0>
mov    $0x1,%eax
mov    %rax,(%rsp)
xor    %r14d,%r14d
mov    $0x1,%bl
mov    %rbx,%rbp
mov    $0x1,%al
mov    %rax,0x10(%rsp)
xor    %ebx,%ebx
jmp    1470 <ConvertSRTTimestamp+0x2e0>
mov    $0x3,%eax
mov    %rax,(%rsp)
mov    $0x1,%r14d
jmp    1465 <ConvertSRTTimestamp+0x2d5>
mov    $0x4,%eax
mov    %rax,(%rsp)
mov    $0x2,%r14d
jmp    1465 <ConvertSRTTimestamp+0x2d5>
mov    $0x5,%eax
mov    %rax,(%rsp)
mov    $0x3,%r14d
mov    $0x1,%al
mov    %rax,0x10(%rsp)
xor    %ebp,%ebp
mov    $0x1,%bl
xor    %edi,%edi
cmp    $0x4,%r14d
setb   %dil
call   1090 <assert@plt>
mov    %r14d,%eax
movb   $0x0,0x24(%rsp,%rax,1)
test   %bl,%bl
je     1639 <ConvertSRTTimestamp+0x4a9>
movzbl 0x10(%rsp),%r15d
mov    %r15d,%edi
call   1090 <assert@plt>
mov    (%rsp),%ebp
mov    (%r12,%rbp,1),%al
mov    $0x1,%bl
test   %al,%al
je     1676 <ConvertSRTTimestamp+0x4e6>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbp,1),%cl
test   %rax,%rax
jne    14ca <ConvertSRTTimestamp+0x33a>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1676 <ConvertSRTTimestamp+0x4e6>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     163e <ConvertSRTTimestamp+0x4ae>
mov    (%rsp),%rax
lea    0x1(%rax),%ebx
mov    (%r12,%rbp,1),%al
mov    %al,0x20(%rsp)
mov    %r15d,%edi
call   1090 <assert@plt>
mov    (%r12,%rbx,1),%al
mov    $0x1,%r13d
test   %al,%al
je     1643 <ConvertSRTTimestamp+0x4b3>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbx,1),%cl
test   %rax,%rax
jne    1520 <ConvertSRTTimestamp+0x390>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1643 <ConvertSRTTimestamp+0x4b3>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     164b <ConvertSRTTimestamp+0x4bb>
mov    (%rsp),%rax
lea    0x2(%rax),%ebp
mov    (%r12,%rbx,1),%al
mov    %al,0x21(%rsp)
mov    %r15d,%edi
call   1090 <assert@plt>
mov    (%r12,%rbp,1),%al
mov    $0x2,%r13d
test   %al,%al
je     1657 <ConvertSRTTimestamp+0x4c7>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbp,1),%cl
test   %rax,%rax
jne    1578 <ConvertSRTTimestamp+0x3e8>
cmp    $0x3a,%cl
mov    $0x3a,%cl
mov    $0x1,%bl
jne    1863 <ConvertSRTTimestamp+0x6d3>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     165f <ConvertSRTTimestamp+0x4cf>
mov    (%rsp),%rax
lea    0x3(%rax),%ebx
mov    (%r12,%rbp,1),%al
mov    %al,0x22(%rsp)
mov    %r15d,%edi
call   1090 <assert@plt>
mov    (%r12,%rbx,1),%al
mov    $0x3,%r13d
test   %al,%al
je     1643 <ConvertSRTTimestamp+0x4b3>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbx,1),%cl
test   %rax,%rax
jne    15ca <ConvertSRTTimestamp+0x43a>
cmp    $0x3a,%cl
mov    $0x3a,%cl
jne    1643 <ConvertSRTTimestamp+0x4b3>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     186c <ConvertSRTTimestamp+0x6dc>
mov    (%rsp),%rbp
add    $0x4,%ebp
mov    (%r12,%rbx,1),%al
mov    %al,0x23(%rsp)
mov    %r15d,%edi
call   1090 <assert@plt>
mov    (%r12,%rbp,1),%al
mov    $0x4,%r13d
test   %al,%al
mov    %rbp,(%rsp)
je     1c58 <ConvertSRTTimestamp+0xac8>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbp,1),%cl
test   %rax,%rax
jne    1622 <ConvertSRTTimestamp+0x492>
cmp    $0x3a,%cl
mov    $0x3a,%cl
mov    $0x1,%bl
jne    1676 <ConvertSRTTimestamp+0x4e6>
movsbl %cl,%edi
call   1040 <isdigit@plt>
mov    $0x2,%bl
mov    $0x4,%r13d
test   %rax,%rax
jne    1676 <ConvertSRTTimestamp+0x4e6>
jmp    1669 <ConvertSRTTimestamp+0x4d9>
mov    %rbp,%rbx
jmp    1676 <ConvertSRTTimestamp+0x4e6>
xor    %r13d,%r13d
jmp    1669 <ConvertSRTTimestamp+0x4d9>
mov    %rbx,(%rsp)
mov    $0x1,%bl
jmp    1676 <ConvertSRTTimestamp+0x4e6>
mov    $0x1,%r13d
mov    %rbx,(%rsp)
jmp    1669 <ConvertSRTTimestamp+0x4d9>
mov    %rbp,(%rsp)
mov    $0x1,%bl
jmp    1676 <ConvertSRTTimestamp+0x4e6>
mov    $0x2,%r13d
mov    %rbp,(%rsp)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
xor    %ebx,%ebx
xor    %edi,%edi
cmp    $0x4,%r13d
setb   %dil
call   1090 <assert@plt>
mov    %r13d,%eax
movb   $0x0,0x20(%rsp,%rax,1)
xor    %r14d,%r14d
test   %bl,%bl
je     16a0 <ConvertSRTTimestamp+0x510>
xor    %r15d,%r15d
mov    (%rsp),%r13
jmp    1886 <ConvertSRTTimestamp+0x6f6>
movzbl 0x10(%rsp),%ebp
mov    %ebp,%edi
call   1090 <assert@plt>
mov    (%rsp),%r13
mov    %r13d,%ebx
mov    (%r12,%rbx,1),%al
test   %al,%al
je     1773 <ConvertSRTTimestamp+0x5e3>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbx,1),%cl
test   %rax,%rax
jne    16db <ConvertSRTTimestamp+0x54b>
cmp    $0x2c,%cl
mov    $0x2c,%cl
jne    1773 <ConvertSRTTimestamp+0x5e3>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     177d <ConvertSRTTimestamp+0x5ed>
add    $0x1,%r13d
mov    (%r12,%rbx,1),%al
mov    %al,0x1c(%rsp)
mov    %ebp,%ebx
mov    %ebp,%edi
call   1090 <assert@plt>
mov    (%r12,%r13,1),%al
mov    $0x1,%r15d
test   %al,%al
je     1785 <ConvertSRTTimestamp+0x5f5>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%r13,1),%cl
test   %rax,%rax
jne    1727 <ConvertSRTTimestamp+0x597>
cmp    $0x2c,%cl
mov    $0x2c,%cl
jne    1785 <ConvertSRTTimestamp+0x5f5>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     178c <ConvertSRTTimestamp+0x5fc>
mov    (%rsp),%rax
lea    0x2(%rax),%ebp
mov    (%r12,%r13,1),%al
mov    %al,0x1d(%rsp)
mov    %ebx,%edi
call   1090 <assert@plt>
mov    (%r12,%rbp,1),%al
mov    $0x2,%r15d
test   %al,%al
je     1854 <ConvertSRTTimestamp+0x6c4>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbp,1),%cl
test   %rax,%rax
je     1797 <ConvertSRTTimestamp+0x607>
mov    (%rsp),%r13
jmp    17a6 <ConvertSRTTimestamp+0x616>
xor    %r15d,%r15d
mov    $0x1,%bl
jmp    1886 <ConvertSRTTimestamp+0x6f6>
xor    %r15d,%r15d
jmp    1880 <ConvertSRTTimestamp+0x6f0>
mov    $0x1,%bl
jmp    1886 <ConvertSRTTimestamp+0x6f6>
mov    $0x1,%r15d
jmp    1880 <ConvertSRTTimestamp+0x6f0>
cmp    $0x2c,%cl
mov    $0x2c,%cl
mov    (%rsp),%r13
jne    1854 <ConvertSRTTimestamp+0x6c4>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     185b <ConvertSRTTimestamp+0x6cb>
mov    %rbp,%rax
lea    0x3(%r13),%ebp
mov    (%r12,%rax,1),%al
mov    %al,0x1e(%rsp)
mov    %ebx,%edi
call   1090 <assert@plt>
mov    (%r12,%rbp,1),%al
mov    $0x3,%r15d
test   %al,%al
je     1854 <ConvertSRTTimestamp+0x6c4>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%rbp,1),%cl
test   %rax,%rax
jne    17f3 <ConvertSRTTimestamp+0x663>
cmp    $0x2c,%cl
mov    $0x2c,%cl
jne    1854 <ConvertSRTTimestamp+0x6c4>
movsbl %cl,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1877 <ConvertSRTTimestamp+0x6e7>
add    $0x4,%r13d
mov    (%r12,%rbp,1),%al
mov    %al,0x1f(%rsp)
mov    %ebx,%edi
call   1090 <assert@plt>
mov    (%r12,%r13,1),%al
mov    $0x4,%r15d
test   %al,%al
je     1c5f <ConvertSRTTimestamp+0xacf>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    (%r12,%r13,1),%cl
test   %rax,%rax
mov    $0x1,%bl
jne    183f <ConvertSRTTimestamp+0x6af>
cmp    $0x2c,%cl
mov    $0x2c,%cl
jne    1886 <ConvertSRTTimestamp+0x6f6>
movsbl %cl,%edi
call   1040 <isdigit@plt>
mov    $0x4,%r15d
test   %rax,%rax
jne    1886 <ConvertSRTTimestamp+0x6f6>
jmp    1880 <ConvertSRTTimestamp+0x6f0>
mov    %ebp,%r13d
mov    $0x1,%bl
jmp    1886 <ConvertSRTTimestamp+0x6f6>
mov    $0x2,%r15d
jmp    187d <ConvertSRTTimestamp+0x6ed>
mov    %rbp,(%rsp)
jmp    1676 <ConvertSRTTimestamp+0x4e6>
mov    $0x3,%r13d
jmp    1651 <ConvertSRTTimestamp+0x4c1>
mov    $0x3,%r15d
mov    %ebp,%r13d
add    $0x1,%r13d
xor    %ebx,%ebx
xor    %edi,%edi
cmp    $0x4,%r15d
setb   %dil
call   1090 <assert@plt>
mov    %r15d,%eax
movb   $0x0,0x1c(%rsp,%rax,1)
test   %bl,%bl
je     18e1 <ConvertSRTTimestamp+0x751>
xor    %edi,%edi
cmp    $0x4,%r14d
setb   %dil
call   1090 <assert@plt>
mov    %r14d,%eax
movb   $0x0,0xc(%rsp,%rax,1)
lea    0x741(%rip),%rdi
mov    %r12,%rsi
call   1060 <printf@plt>
mov    0x28(%rsp),%r14
test   %r14,%r14
je     19e5 <ConvertSRTTimestamp+0x855>
movl   $0x1,(%r14)
jmp    1c0a <ConvertSRTTimestamp+0xa7a>
movzbl 0x10(%rsp),%ebp
mov    %ebp,%edi
call   1090 <assert@plt>
mov    %r13d,%eax
lea    (%r12,%rax,1),%r15
mov    (%r12,%rax,1),%al
test   %al,%al
je     19fd <ConvertSRTTimestamp+0x86d>
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1a04 <ConvertSRTTimestamp+0x874>
lea    0x1(%r13),%ebx
mov    (%r15),%al
mov    %al,0xc(%rsp)
mov    %ebp,%edi
call   1090 <assert@plt>
lea    (%r12,%rbx,1),%r15
mov    (%r12,%rbx,1),%al
test   %al,%al
je     1a09 <ConvertSRTTimestamp+0x879>
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1a11 <ConvertSRTTimestamp+0x881>
lea    0x2(%r13),%ebx
mov    (%r15),%al
mov    %al,0xd(%rsp)
mov    %ebp,%edi
call   1090 <assert@plt>
lea    (%r12,%rbx,1),%r15
mov    (%r12,%rbx,1),%al
test   %al,%al
je     1a19 <ConvertSRTTimestamp+0x889>
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1a21 <ConvertSRTTimestamp+0x891>
lea    0x3(%r13),%ebx
mov    (%r15),%al
mov    %al,0xe(%rsp)
mov    %ebp,%edi
call   1090 <assert@plt>
lea    (%r12,%rbx,1),%r15
mov    (%r12,%rbx,1),%al
test   %al,%al
je     1a29 <ConvertSRTTimestamp+0x899>
movsbl %al,%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     1a36 <ConvertSRTTimestamp+0x8a6>
add    $0x4,%r13d
mov    (%r15),%al
mov    %al,0xf(%rsp)
mov    %ebp,%edi
call   1090 <assert@plt>
lea    (%r12,%r13,1),%r15
mov    (%r12,%r13,1),%al
test   %al,%al
je     1c4b <ConvertSRTTimestamp+0xabb>
movsbl %al,%edi
call   1040 <isdigit@plt>
mov    $0x4,%r14d
test   %rax,%rax
jne    18a1 <ConvertSRTTimestamp+0x711>
jmp    1a3f <ConvertSRTTimestamp+0x8af>
lea    0x656(%rip),%rdi
call   1050 <puts@plt>
mov    $0x1,%edi
call   1070 <exit_wrapper@plt>
jmp    1a6f <ConvertSRTTimestamp+0x8df>
xor    %r14d,%r14d
xor    %eax,%eax
jmp    1a42 <ConvertSRTTimestamp+0x8b2>
xor    %r14d,%r14d
jmp    1a3f <ConvertSRTTimestamp+0x8af>
mov    $0x1,%r14d
jmp    1a2f <ConvertSRTTimestamp+0x89f>
mov    $0x1,%r14d
jmp    1a3c <ConvertSRTTimestamp+0x8ac>
mov    $0x2,%r14d
jmp    1a2f <ConvertSRTTimestamp+0x89f>
mov    $0x2,%r14d
jmp    1a3c <ConvertSRTTimestamp+0x8ac>
mov    $0x3,%r14d
xor    %eax,%eax
mov    %ebx,%r13d
jmp    1a42 <ConvertSRTTimestamp+0x8b2>
mov    $0x3,%r14d
mov    %ebx,%r13d
mov    (%r15),%al
movsbl %al,%edi
call   1080 <isspace@plt>
test   %rax,%rax
je     1b6f <ConvertSRTTimestamp+0x9df>
xor    %edi,%edi
cmp    $0x4,%r14d
setb   %dil
call   1090 <assert@plt>
mov    %r14d,%eax
movb   $0x0,0xc(%rsp,%rax,1)
mov    0x28(%rsp),%r14
mov    0x30(%rsp),%rbx
test   %rbx,%rbx
setne  %al
and    0x10(%rsp),%al
movzbl %al,%edi
call   1090 <assert@plt>
add    $0x1,%r13d
add    %r13,%r12
mov    %r12,(%rbx)
lea    0x24(%rsp),%rdi
call   10b0 <RemoveLeadingZeroes@plt>
mov    %rax,%rbp
cmpb   $0x30,(%rax)
jne    1aa6 <ConvertSRTTimestamp+0x916>
xor    %ebx,%ebx
jmp    1ac1 <ConvertSRTTimestamp+0x931>
mov    %rbp,%rdi
call   10a0 <atol@plt>
mov    %rax,%rbx
test   %rax,%rax
jle    1b7e <ConvertSRTTimestamp+0x9ee>
imul   $0x36ee80,%rbx,%rbx
mov    %rbp,%rdi
call   1030 <free@plt>
lea    0x20(%rsp),%rdi
call   10b0 <RemoveLeadingZeroes@plt>
mov    %rax,%rbp
cmpb   $0x30,(%rax)
je     1af9 <ConvertSRTTimestamp+0x969>
mov    %rbp,%rdi
call   10a0 <atol@plt>
mov    %rax,%r15
test   %rax,%rax
jle    1ba6 <ConvertSRTTimestamp+0xa16>
imul   $0xea60,%r15,%rax
add    %rax,%rbx
mov    %rbp,%rdi
call   1030 <free@plt>
lea    0x1c(%rsp),%rdi
call   10b0 <RemoveLeadingZeroes@plt>
mov    %rax,%rbp
cmpb   $0x30,(%rax)
je     1b31 <ConvertSRTTimestamp+0x9a1>
mov    %rbp,%rdi
call   10a0 <atol@plt>
mov    %rax,%r15
test   %rax,%rax
jle    1bc8 <ConvertSRTTimestamp+0xa38>
imul   $0x3e8,%r15,%rax
add    %rax,%rbx
mov    %rbp,%rdi
call   1030 <free@plt>
lea    0xc(%rsp),%rdi
call   10b0 <RemoveLeadingZeroes@plt>
mov    %rax,%rbp
cmpb   $0x30,(%rax)
je     1b62 <ConvertSRTTimestamp+0x9d2>
mov    %rbp,%rdi
call   10a0 <atol@plt>
mov    %rax,%r15
test   %rax,%rax
jle    1bea <ConvertSRTTimestamp+0xa5a>
add    %r15,%rbx
mov    %rbp,%rdi
call   1030 <free@plt>
jmp    1c0c <ConvertSRTTimestamp+0xa7c>
cmpb   $0x0,(%r15)
jne    18a1 <ConvertSRTTimestamp+0x711>
jmp    1a53 <ConvertSRTTimestamp+0x8c3>
lea    0x49a(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
test   %r14,%r14
jne    1bbf <ConvertSRTTimestamp+0xa2f>
mov    $0x2,%edi
call   1070 <exit_wrapper@plt>
jmp    1aba <ConvertSRTTimestamp+0x92a>
lea    0x472(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
test   %r14,%r14
je     1c1e <ConvertSRTTimestamp+0xa8e>
movl   $0x2,(%r14)
jmp    1c0a <ConvertSRTTimestamp+0xa7a>
lea    0x450(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
test   %r14,%r14
je     1c2d <ConvertSRTTimestamp+0xa9d>
movl   $0x3,(%r14)
jmp    1c0a <ConvertSRTTimestamp+0xa7a>
lea    0x42e(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
test   %r14,%r14
je     1c3c <ConvertSRTTimestamp+0xaac>
movl   $0x4,(%r14)
xor    %ebx,%ebx
mov    %rbx,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x2,%edi
call   1070 <exit_wrapper@plt>
jmp    1aef <ConvertSRTTimestamp+0x95f>
mov    $0x3,%edi
call   1070 <exit_wrapper@plt>
jmp    1b27 <ConvertSRTTimestamp+0x997>
mov    $0x4,%edi
call   1070 <exit_wrapper@plt>
jmp    1b5f <ConvertSRTTimestamp+0x9cf>
mov    $0x4,%r14d
xor    %eax,%eax
jmp    1a42 <ConvertSRTTimestamp+0x8b2>
mov    $0x1,%bl
jmp    1676 <ConvertSRTTimestamp+0x4e6>
mov    $0x1,%bl
jmp    1886 <ConvertSRTTimestamp+0x6f6>

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

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