#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 atof(char *);
char *convert_deg_to_str(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ sprintf(char *, char *, char *, char *);
char *strchr(char *, char);
int /*<<< orphan*/ strcmp(char *, char *);
int strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, int);
char *strstr(char *, char *);
void search_rep(char *line, char *key_i, char *key_o) {
  int i, j;
  char *equal;
  int to_copy;
  char *p;
  char tmp[80 + 1];
  char comment[80 + 1];
  equal = strstr(line, "=");
  to_copy = 80 - (equal - line);
  for (i = 0; i < (int)strlen(key_o); i++) {
    line[i] = key_o[i];
  }
  if (strlen(key_o) <= 8) {
    for (; i < 8; i++) {
      line[i] = ' ';
    }
    line[i] = '=';
    i++;
    if (!strcmp(key_o, "RA")) {
      if (*(equal + 2) != '\'') {
        p = strchr(line + i, '/');
        if (p)
          strncpy(comment, p, line + 80 - p);
        sprintf(tmp, " %-29.29s %-40.40s",
                convert_deg_to_str(atof(equal + 1) / 15.),
                (p) ? comment : "/ Right Ascension");
        memcpy(line + i, tmp, 71);
      }
    } else if (!strcmp(key_o, "DEC")) {
      if (*(equal + 2) != '\'') {
        p = strchr(line + i, '/');
        if (p)
          strncpy(comment, p, line + 80 - p);
        sprintf(tmp, " %-29.29s %-40.40s", convert_deg_to_str(atof(equal + 1)),
                (p) ? comment : "/ Declination");
        memcpy(line + i, tmp, 71);
      }
    } else if (!strcmp(key_o, "UT")) {
      if (*(equal + 2) != '\'') {
        p = strchr(line + i, '/');
        if (p)
          strncpy(comment, p, line + 80 - p);
        sprintf(tmp, " %-29.29s %-40.40s",
                convert_deg_to_str(atof(equal + 1) / 3600.),
                (p) ? comment : "/ UT");
        memcpy(line + i, tmp, 71);
      }
    } else if (!strcmp(key_o, "ST")) {
      if (*(equal + 2) != '\'') {
        p = strchr(line + i, '/');
        if (p)
          strncpy(comment, p, line + 80 - p);
        sprintf(tmp, " %-29.29s %-40.40s",
                convert_deg_to_str(atof(equal + 1) / 3600.),
                (p) ? comment : "/ ST");
        memcpy(line + i, tmp, 71);
      }
    } else {
      for (j = 0; j < to_copy; j++) {
        line[i + j] = equal[j + 1];
      }
      i += to_copy - 1;
      for (; i < 80; i++) {
        line[i] = ' ';
      }
    }
  } else {
    for (i = (int)strlen(key_o); i < (int)strlen(key_i); i++) {
      line[i] = ' ';
    }
  }
  return;
}


x86 assembly (clang, -O0):
<search_rep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe5e(%rip),%rsi
call   10b0 <strstr@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
sub    %rax,%rcx
mov    $0x50,%eax
sub    %rcx,%rax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,%ecx
mov    -0xf4(%rbp),%eax
cmp    %ecx,%eax
jge    121e <search_rep+0x8e>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d8 <search_rep+0x48>
mov    -0x18(%rbp),%rdi
call   1060 <strlen@plt>
cmp    $0x8,%eax
jg     175a <search_rep+0x5ca>
jmp    1235 <search_rep+0xa5>
cmpl   $0x8,-0x1c(%rbp)
jge    1259 <search_rep+0xc9>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1235 <search_rep+0xa5>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x3d,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rdi
lea    0xd99(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    138b <search_rep+0x1fb>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x27,%eax
je     1386 <search_rep+0x1f6>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     12dd <search_rep+0x14d>
lea    -0xf0(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x8(%rbp),%rax
add    $0x50,%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <strncpy@plt>
lea    -0x90(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   1050 <atof@plt>
cvtsi2sd %eax,%xmm0
movsd  0xcfc(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <convert_deg_to_str@plt>
mov    %rax,-0x100(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     1336 <search_rep+0x1a6>
lea    -0xf0(%rbp),%rax
mov    %rax,-0x110(%rbp)
jmp    1349 <search_rep+0x1b9>
lea    0xceb(%rip),%rax
mov    %rax,-0x110(%rbp)
jmp    1349 <search_rep+0x1b9>
mov    -0x100(%rbp),%rdx
mov    -0x108(%rbp),%rdi
mov    -0x110(%rbp),%rcx
lea    0xcb0(%rip),%rsi
call   10a0 <sprintf@plt>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
lea    -0x90(%rbp),%rsi
mov    $0x47,%edx
call   1090 <memcpy@plt>
jmp    1755 <search_rep+0x5c5>
mov    -0x18(%rbp),%rdi
lea    0xca4(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    1496 <search_rep+0x306>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x27,%eax
je     1491 <search_rep+0x301>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     13fa <search_rep+0x26a>
lea    -0xf0(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x8(%rbp),%rax
add    $0x50,%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <strncpy@plt>
lea    -0x90(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   1050 <atof@plt>
mov    %eax,%edi
call   1040 <convert_deg_to_str@plt>
mov    %rax,-0x118(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     1441 <search_rep+0x2b1>
lea    -0xf0(%rbp),%rax
mov    %rax,-0x128(%rbp)
jmp    1454 <search_rep+0x2c4>
lea    0xbf6(%rip),%rax
mov    %rax,-0x128(%rbp)
jmp    1454 <search_rep+0x2c4>
mov    -0x118(%rbp),%rdx
mov    -0x120(%rbp),%rdi
mov    -0x128(%rbp),%rcx
lea    0xba5(%rip),%rsi
call   10a0 <sprintf@plt>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
lea    -0x90(%rbp),%rsi
mov    $0x47,%edx
call   1090 <memcpy@plt>
jmp    1750 <search_rep+0x5c0>
mov    -0x18(%rbp),%rdi
lea    0xbad(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    15b3 <search_rep+0x423>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x27,%eax
je     15ae <search_rep+0x41e>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     1505 <search_rep+0x375>
lea    -0xf0(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x8(%rbp),%rax
add    $0x50,%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <strncpy@plt>
lea    -0x90(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   1050 <atof@plt>
cvtsi2sd %eax,%xmm0
movsd  0xadc(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <convert_deg_to_str@plt>
mov    %rax,-0x130(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     155e <search_rep+0x3ce>
lea    -0xf0(%rbp),%rax
mov    %rax,-0x140(%rbp)
jmp    1571 <search_rep+0x3e1>
lea    0xae7(%rip),%rax
mov    %rax,-0x140(%rbp)
jmp    1571 <search_rep+0x3e1>
mov    -0x130(%rbp),%rdx
mov    -0x138(%rbp),%rdi
mov    -0x140(%rbp),%rcx
lea    0xa88(%rip),%rsi
call   10a0 <sprintf@plt>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
lea    -0x90(%rbp),%rsi
mov    $0x47,%edx
call   1090 <memcpy@plt>
jmp    174b <search_rep+0x5bb>
mov    -0x18(%rbp),%rdi
lea    0xa95(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    16d0 <search_rep+0x540>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x27,%eax
je     16cb <search_rep+0x53b>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     1622 <search_rep+0x492>
lea    -0xf0(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x8(%rbp),%rax
add    $0x50,%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <strncpy@plt>
lea    -0x90(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   1050 <atof@plt>
cvtsi2sd %eax,%xmm0
movsd  0x9bf(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <convert_deg_to_str@plt>
mov    %rax,-0x148(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     167b <search_rep+0x4eb>
lea    -0xf0(%rbp),%rax
mov    %rax,-0x158(%rbp)
jmp    168e <search_rep+0x4fe>
lea    0x9cf(%rip),%rax
mov    %rax,-0x158(%rbp)
jmp    168e <search_rep+0x4fe>
mov    -0x148(%rbp),%rdx
mov    -0x150(%rbp),%rdi
mov    -0x158(%rbp),%rcx
lea    0x96b(%rip),%rsi
call   10a0 <sprintf@plt>
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rax
add    %rax,%rdi
lea    -0x90(%rbp),%rsi
mov    $0x47,%edx
call   1090 <memcpy@plt>
jmp    1746 <search_rep+0x5b6>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1711 <search_rep+0x581>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    16d7 <search_rep+0x547>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x50,-0x1c(%rbp)
jge    1741 <search_rep+0x5b1>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    171d <search_rep+0x58d>
jmp    1746 <search_rep+0x5b6>
jmp    174b <search_rep+0x5bb>
jmp    1750 <search_rep+0x5c0>
jmp    1755 <search_rep+0x5c5>
jmp    17a7 <search_rep+0x617>
mov    -0x18(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x10(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,%ecx
mov    -0x15c(%rbp),%eax
cmp    %ecx,%eax
jge    17a2 <search_rep+0x612>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1766 <search_rep+0x5d6>
jmp    17a7 <search_rep+0x617>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<search_rep>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc0,%rsp
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%r15
mov    $0x3d,%esi
call   1070 <strchr@plt>
mov    %rax,%r14
mov    %r12,%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    1204 <search_rep+0x74>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12,%rbx,1),%eax
mov    %al,(%r15,%rbx,1)
add    $0x1,%rbx
mov    %r12,%rdi
call   1060 <strlen@plt>
cltq
cmp    %rax,%rbx
jl     11d0 <search_rep+0x40>
mov    %r12,%rdi
call   1060 <strlen@plt>
cmp    $0x9,%eax
jge    131b <search_rep+0x18b>
cmp    $0x7,%ebx
jbe    1217 <search_rep+0x87>
jmp    1236 <search_rep+0xa6>
mov    %r12,%rdi
call   1060 <strlen@plt>
xor    %ebx,%ebx
cmp    $0x9,%eax
jge    131b <search_rep+0x18b>
mov    %ebx,%edi
add    %r15,%rdi
mov    $0x7,%edx
sub    %ebx,%edx
add    $0x1,%rdx
mov    $0x20,%esi
call   1080 <memset@plt>
mov    $0x8,%ebx
mov    %ebx,%r13d
movb   $0x3d,(%r15,%r13,1)
add    $0x1,%r13
lea    0xdc7(%rip),%rsi
mov    %r12,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
je     135d <search_rep+0x1cd>
lea    0xdd8(%rip),%rsi
mov    %r12,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
je     13a1 <search_rep+0x211>
lea    0xdd5(%rip),%rsi
mov    %r12,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
je     13e5 <search_rep+0x255>
lea    0xdc3(%rip),%rsi
mov    %r12,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
je     1411 <search_rep+0x281>
mov    %r15d,%r9d
sub    %r14d,%r9d
lea    0x50(%r9),%eax
test   %eax,%eax
jle    1533 <search_rep+0x3a3>
mov    %eax,%r11d
cmp    $0x8,%eax
jb     12e4 <search_rep+0x154>
lea    (%r15,%r13,1),%r10
lea    (%r11,%r14,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r10
jae    1563 <search_rep+0x3d3>
lea    (%r11,%r13,1),%rcx
add    %r15,%rcx
mov    %r14,%rdx
add    $0x1,%rdx
cmp    %rcx,%rdx
jae    1563 <search_rep+0x3d3>
xor    %edx,%edx
mov    %rdx,%r8
not    %r8
add    %r11,%r8
mov    %r11,%rax
and    $0x3,%rax
je     14e4 <search_rep+0x354>
lea    (%r15,%r13,1),%rdi
lea    0x1(%rdx),%rsi
movzbl 0x1(%r14,%rdx,1),%ecx
mov    %cl,(%rdi,%rdx,1)
mov    %rsi,%rdx
add    $0xffffffffffffffff,%rax
jne    1300 <search_rep+0x170>
jmp    14e7 <search_rep+0x357>
mov    %r12,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
mov    %r13,%rdi
call   1060 <strlen@plt>
cmp    %eax,%ebx
jge    14d3 <search_rep+0x343>
movslq %ebx,%rbx
nopl   0x0(%rax,%rax,1)
movb   $0x20,(%r15,%rbx,1)
add    $0x1,%rbx
mov    %r13,%rdi
call   1060 <strlen@plt>
cltq
cmp    %rax,%rbx
jl     1340 <search_rep+0x1b0>
jmp    14d3 <search_rep+0x343>
cmpb   $0x27,0x2(%r14)
je     14d3 <search_rep+0x343>
mov    %r13d,%ebx
add    %r15,%rbx
mov    %rbx,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
test   %rax,%rax
je     146a <search_rep+0x2da>
mov    %rsp,%r12
sub    %eax,%r15d
add    $0x50,%r15d
mov    %r12,%rdi
mov    %rax,%rsi
mov    %r15d,%edx
call   1030 <strncpy@plt>
jmp    1471 <search_rep+0x2e1>
cmpb   $0x27,0x2(%r14)
je     14d3 <search_rep+0x343>
mov    %r13d,%ebx
add    %r15,%rbx
mov    %rbx,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
test   %rax,%rax
je     148f <search_rep+0x2ff>
mov    %rsp,%r12
sub    %eax,%r15d
add    $0x50,%r15d
mov    %r12,%rdi
mov    %rax,%rsi
mov    %r15d,%edx
call   1030 <strncpy@plt>
jmp    1496 <search_rep+0x306>
cmpb   $0x27,0x2(%r14)
je     14d3 <search_rep+0x343>
mov    %r13d,%ebx
add    %r15,%rbx
mov    %rbx,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
test   %rax,%rax
jne    1438 <search_rep+0x2a8>
lea    0xc3b(%rip),%r12
jmp    1450 <search_rep+0x2c0>
cmpb   $0x27,0x2(%r14)
je     14d3 <search_rep+0x343>
mov    %r13d,%ebx
add    %r15,%rbx
mov    %rbx,%rdi
mov    $0x2f,%esi
call   1070 <strchr@plt>
test   %rax,%rax
je     156f <search_rep+0x3df>
mov    %rsp,%r12
sub    %eax,%r15d
add    $0x50,%r15d
mov    %r12,%rdi
mov    %rax,%rsi
mov    %r15d,%edx
call   1030 <strncpy@plt>
add    $0x1,%r14
mov    %r14,%rdi
call   1050 <atof@plt>
cvtsi2sd %eax,%xmm0
divsd  0xb98(%rip),%xmm0
jmp    1489 <search_rep+0x2f9>
lea    0xbb5(%rip),%r12
add    $0x1,%r14
mov    %r14,%rdi
call   1050 <atof@plt>
cvtsi2sd %eax,%xmm0
divsd  0xb7f(%rip),%xmm0
cvttsd2si %xmm0,%edi
jmp    14a4 <search_rep+0x314>
lea    0xba6(%rip),%r12
add    $0x1,%r14
mov    %r14,%rdi
call   1050 <atof@plt>
mov    %eax,%edi
call   1040 <convert_deg_to_str@plt>
lea    0xb63(%rip),%rsi
lea    0x60(%rsp),%r14
mov    %r14,%rdi
mov    %rax,%rdx
mov    %r12,%rcx
call   10b0 <sprintf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x47,%edx
call   10a0 <memcpy@plt>
add    $0xc0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
mov    %rdx,%rsi
cmp    $0x3,%r8
jb     1533 <search_rep+0x3a3>
lea    (%r15,%r13,1),%rax
add    $0x3,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%r14,%rsi,1),%ecx
mov    %cl,-0x3(%rax,%rsi,1)
movzbl 0x2(%r14,%rsi,1),%ecx
mov    %cl,-0x2(%rax,%rsi,1)
movzbl 0x3(%r14,%rsi,1),%ecx
mov    %cl,-0x1(%rax,%rsi,1)
movzbl 0x4(%r14,%rsi,1),%ecx
mov    %cl,(%rax,%rsi,1)
lea    0x4(%rsi),%rcx
mov    %rcx,%rsi
cmp    %rcx,%r11
jne    1500 <search_rep+0x370>
lea    (%r9,%r13,1),%eax
add    $0x4f,%eax
cmp    $0x4f,%eax
jg     14d3 <search_rep+0x343>
movslq %eax,%rdi
add    %r15,%rdi
not    %ebx
add    %r14d,%ebx
sub    %r15d,%ebx
add    $0x1,%rbx
mov    $0x20,%esi
mov    %rbx,%rdx
call   1080 <memset@plt>
jmp    14d3 <search_rep+0x343>
cmp    $0x20,%eax
jae    157b <search_rep+0x3eb>
xor    %edx,%edx
jmp    161c <search_rep+0x48c>
lea    0xad9(%rip),%r12
jmp    1450 <search_rep+0x2c0>
mov    %r11d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rax,%rax
je     15df <search_rep+0x44f>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r15,%r13,1),%rsi
add    $0x30,%rsi
xor    %edi,%edi
movups 0x1(%r14,%rdi,1),%xmm0
movups 0x11(%r14,%rdi,1),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,1)
movups %xmm1,-0x20(%rsi,%rdi,1)
movupd 0x21(%r14,%rdi,1),%xmm0
movups 0x31(%r14,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rax
jne    15a6 <search_rep+0x416>
jmp    15e1 <search_rep+0x451>
xor    %edi,%edi
test   $0x1,%r8b
je     1609 <search_rep+0x479>
mov    %rdi,%rax
or     $0x1,%rax
movupd (%r14,%rax,1),%xmm0
movups 0x10(%r14,%rax,1),%xmm1
add    %r13,%rdi
movupd %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
cmp    %r11,%rdx
je     1533 <search_rep+0x3a3>
test   $0x18,%r11b
je     12e6 <search_rep+0x156>
mov    %rdx,%rax
mov    %r11d,%edx
and    $0xfffffff8,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1(%r14,%rax,1),%rcx
mov    %rcx,(%r10,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdx
jne    1630 <search_rep+0x4a0>
cmp    %r11,%rdx
je     1533 <search_rep+0x3a3>
jmp    12e6 <search_rep+0x156>

LLVM IR (-O0):
@.str = [2 x i8] c"=\00"
@.str.1 = [3 x i8] c"RA\00"
@.str.2 = [19 x i8] c" %-29.29s %-40.40s\00"
@.str.3 = [18 x i8] c"/ Right Ascension\00"
@.str.4 = [4 x i8] c"DEC\00"
@.str.5 = [14 x i8] c"/ Declination\00"
@.str.6 = [3 x i8] c"UT\00"
@.str.7 = [5 x i8] c"/ UT\00"
@.str.8 = [3 x i8] c"ST\00"
@.str.9 = [5 x i8] c"/ ST\00"
define void @search_rep(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca [81 x i8]
%13 = alloca [81 x i8]
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
%14 = load i8*, i8** %4
%15 = call i8* @strstr(i8* %14, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i8* %15, i8** %9
%16 = load i8*, i8** %9
%17 = load i8*, i8** %4
%18 = ptrtoint i8* %16 to i64
%19 = ptrtoint i8* %17 to i64
%20 = sub i64 %18, %19
%21 = sub nsw i64 80, %20
%22 = trunc i64 %21 to i32
store i32 %22, i32* %10
store i32 0, i32* %7
br label %23
23: ; preds = %38, %3
%24 = load i32, i32* %7
%25 = load i8*, i8** %6
%26 = call i32 @strlen(i8* %25)
%27 = icmp slt i32 %24, %26
br i1 %27, label %28, label %41
28: ; preds = %23
%29 = load i8*, i8** %6
%30 = load i32, i32* %7
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8, i8* %29, i64 %31
%33 = load i8, i8* %32
%34 = load i8*, i8** %4
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %34, i64 %36
store i8 %33, i8* %37
br label %38
38: ; preds = %28
%39 = load i32, i32* %7
%40 = add nsw i32 %39, 1
store i32 %40, i32* %7
br label %23
41: ; preds = %23
%42 = load i8*, i8** %6
%43 = call i32 @strlen(i8* %42)
%44 = icmp sle i32 %43, 8
br i1 %44, label %45, label %314
45: ; preds = %41
br label %46
46: ; preds = %54, %45
%47 = load i32, i32* %7
%48 = icmp slt i32 %47, 8
br i1 %48, label %49, label %57
49: ; preds = %46
%50 = load i8*, i8** %4
%51 = load i32, i32* %7
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %50, i64 %52
store i8 32, i8* %53
br label %54
54: ; preds = %49
%55 = load i32, i32* %7
%56 = add nsw i32 %55, 1
store i32 %56, i32* %7
br label %46
57: ; preds = %46
%58 = load i8*, i8** %4
%59 = load i32, i32* %7
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %58, i64 %60
store i8 61, i8* %61
%62 = load i32, i32* %7
%63 = add nsw i32 %62, 1
store i32 %63, i32* %7
%64 = load i8*, i8** %6
%65 = call i32 @strcmp(i8* %64, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%66 = icmp ne i32 %65, 0
br i1 %66, label %116, label %67
67: ; preds = %57
%68 = load i8*, i8** %9
%69 = getelementptr inbounds i8, i8* %68, i64 2
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = icmp ne i32 %71, 39
br i1 %72, label %73, label %115
73: ; preds = %67
%74 = load i8*, i8** %4
%75 = load i32, i32* %7
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
%78 = call i8* @strchr(i8* %77, i8 signext 47)
store i8* %78, i8** %11
%79 = load i8*, i8** %11
%80 = icmp ne i8* %79, null
br i1 %80, label %81, label %92
81: ; preds = %73
%82 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
%83 = load i8*, i8** %11
%84 = load i8*, i8** %4
%85 = getelementptr inbounds i8, i8* %84, i64 80
%86 = load i8*, i8** %11
%87 = ptrtoint i8* %85 to i64
%88 = ptrtoint i8* %86 to i64
%89 = sub i64 %87, %88
%90 = trunc i64 %89 to i32
%91 = call i32 @strncpy(i8* %82, i8* %83, i32 %90)
br label %92
92: ; preds = %81, %73
%93 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%94 = load i8*, i8** %9
%95 = getelementptr inbounds i8, i8* %94, i64 1
%96 = call i32 @atof(i8* %95)
%97 = sitofp i32 %96 to double
%98 = fdiv double %97, 1.500000e+01
%99 = fptosi double %98 to i32
%100 = call i8* @convert_deg_to_str(i32 %99)
%101 = load i8*, i8** %11
%102 = icmp ne i8* %101, null
br i1 %102, label %103, label %105
103: ; preds = %92
%104 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
br label %106
105: ; preds = %92
br label %106
106: ; preds = %105, %103
%107 = phi i8* [ %104, %103 ], [ getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), %105 ]
%108 = call i32 @sprintf(i8* %93, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %100, i8* %107)
%109 = load i8*, i8** %4
%110 = load i32, i32* %7
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %109, i64 %111
%113 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%114 = call i32 @memcpy(i8* %112, i8* %113, i32 71)
br label %115
115: ; preds = %106, %67
br label %313
116: ; preds = %57
%117 = load i8*, i8** %6
%118 = call i32 @strcmp(i8* %117, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0))
%119 = icmp ne i32 %118, 0
br i1 %119, label %166, label %120
120: ; preds = %116
%121 = load i8*, i8** %9
%122 = getelementptr inbounds i8, i8* %121, i64 2
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp ne i32 %124, 39
br i1 %125, label %126, label %165
126: ; preds = %120
%127 = load i8*, i8** %4
%128 = load i32, i32* %7
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %127, i64 %129
%131 = call i8* @strchr(i8* %130, i8 signext 47)
store i8* %131, i8** %11
%132 = load i8*, i8** %11
%133 = icmp ne i8* %132, null
br i1 %133, label %134, label %145
134: ; preds = %126
%135 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
%136 = load i8*, i8** %11
%137 = load i8*, i8** %4
%138 = getelementptr inbounds i8, i8* %137, i64 80
%139 = load i8*, i8** %11
%140 = ptrtoint i8* %138 to i64
%141 = ptrtoint i8* %139 to i64
%142 = sub i64 %140, %141
%143 = trunc i64 %142 to i32
%144 = call i32 @strncpy(i8* %135, i8* %136, i32 %143)
br label %145
145: ; preds = %134, %126
%146 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%147 = load i8*, i8** %9
%148 = getelementptr inbounds i8, i8* %147, i64 1
%149 = call i32 @atof(i8* %148)
%150 = call i8* @convert_deg_to_str(i32 %149)
%151 = load i8*, i8** %11
%152 = icmp ne i8* %151, null
br i1 %152, label %153, label %155
153: ; preds = %145
%154 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
br label %156
155: ; preds = %145
br label %156
156: ; preds = %155, %153
%157 = phi i8* [ %154, %153 ], [ getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), %155 ]
%158 = call i32 @sprintf(i8* %146, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %150, i8* %157)
%159 = load i8*, i8** %4
%160 = load i32, i32* %7
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8, i8* %159, i64 %161
%163 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%164 = call i32 @memcpy(i8* %162, i8* %163, i32 71)
br label %165
165: ; preds = %156, %120
br label %312
166: ; preds = %116
%167 = load i8*, i8** %6
%168 = call i32 @strcmp(i8* %167, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%169 = icmp ne i32 %168, 0
br i1 %169, label %219, label %170
170: ; preds = %166
%171 = load i8*, i8** %9
%172 = getelementptr inbounds i8, i8* %171, i64 2
%173 = load i8, i8* %172
%174 = sext i8 %173 to i32
%175 = icmp ne i32 %174, 39
br i1 %175, label %176, label %218
176: ; preds = %170
%177 = load i8*, i8** %4
%178 = load i32, i32* %7
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %177, i64 %179
%181 = call i8* @strchr(i8* %180, i8 signext 47)
store i8* %181, i8** %11
%182 = load i8*, i8** %11
%183 = icmp ne i8* %182, null
br i1 %183, label %184, label %195
184: ; preds = %176
%185 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
%186 = load i8*, i8** %11
%187 = load i8*, i8** %4
%188 = getelementptr inbounds i8, i8* %187, i64 80
%189 = load i8*, i8** %11
%190 = ptrtoint i8* %188 to i64
%191 = ptrtoint i8* %189 to i64
%192 = sub i64 %190, %191
%193 = trunc i64 %192 to i32
%194 = call i32 @strncpy(i8* %185, i8* %186, i32 %193)
br label %195
195: ; preds = %184, %176
%196 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%197 = load i8*, i8** %9
%198 = getelementptr inbounds i8, i8* %197, i64 1
%199 = call i32 @atof(i8* %198)
%200 = sitofp i32 %199 to double
%201 = fdiv double %200, 3.600000e+03
%202 = fptosi double %201 to i32
%203 = call i8* @convert_deg_to_str(i32 %202)
%204 = load i8*, i8** %11
%205 = icmp ne i8* %204, null
br i1 %205, label %206, label %208
206: ; preds = %195
%207 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
br label %209
208: ; preds = %195
br label %209
209: ; preds = %208, %206
%210 = phi i8* [ %207, %206 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), %208 ]
%211 = call i32 @sprintf(i8* %196, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %203, i8* %210)
%212 = load i8*, i8** %4
%213 = load i32, i32* %7
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i8, i8* %212, i64 %214
%216 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%217 = call i32 @memcpy(i8* %215, i8* %216, i32 71)
br label %218
218: ; preds = %209, %170
br label %311
219: ; preds = %166
%220 = load i8*, i8** %6
%221 = call i32 @strcmp(i8* %220, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%222 = icmp ne i32 %221, 0
br i1 %222, label %272, label %223
223: ; preds = %219
%224 = load i8*, i8** %9
%225 = getelementptr inbounds i8, i8* %224, i64 2
%226 = load i8, i8* %225
%227 = sext i8 %226 to i32
%228 = icmp ne i32 %227, 39
br i1 %228, label %229, label %271
229: ; preds = %223
%230 = load i8*, i8** %4
%231 = load i32, i32* %7
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %230, i64 %232
%234 = call i8* @strchr(i8* %233, i8 signext 47)
store i8* %234, i8** %11
%235 = load i8*, i8** %11
%236 = icmp ne i8* %235, null
br i1 %236, label %237, label %248
237: ; preds = %229
%238 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
%239 = load i8*, i8** %11
%240 = load i8*, i8** %4
%241 = getelementptr inbounds i8, i8* %240, i64 80
%242 = load i8*, i8** %11
%243 = ptrtoint i8* %241 to i64
%244 = ptrtoint i8* %242 to i64
%245 = sub i64 %243, %244
%246 = trunc i64 %245 to i32
%247 = call i32 @strncpy(i8* %238, i8* %239, i32 %246)
br label %248
248: ; preds = %237, %229
%249 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%250 = load i8*, i8** %9
%251 = getelementptr inbounds i8, i8* %250, i64 1
%252 = call i32 @atof(i8* %251)
%253 = sitofp i32 %252 to double
%254 = fdiv double %253, 3.600000e+03
%255 = fptosi double %254 to i32
%256 = call i8* @convert_deg_to_str(i32 %255)
%257 = load i8*, i8** %11
%258 = icmp ne i8* %257, null
br i1 %258, label %259, label %261
259: ; preds = %248
%260 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
br label %262
261: ; preds = %248
br label %262
262: ; preds = %261, %259
%263 = phi i8* [ %260, %259 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), %261 ]
%264 = call i32 @sprintf(i8* %249, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %256, i8* %263)
%265 = load i8*, i8** %4
%266 = load i32, i32* %7
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i8, i8* %265, i64 %267
%269 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%270 = call i32 @memcpy(i8* %268, i8* %269, i32 71)
br label %271
271: ; preds = %262, %223
br label %310
272: ; preds = %219
store i32 0, i32* %8
br label %273
273: ; preds = %290, %272
%274 = load i32, i32* %8
%275 = load i32, i32* %10
%276 = icmp slt i32 %274, %275
br i1 %276, label %277, label %293
277: ; preds = %273
%278 = load i8*, i8** %9
%279 = load i32, i32* %8
%280 = add nsw i32 %279, 1
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i8, i8* %278, i64 %281
%283 = load i8, i8* %282
%284 = load i8*, i8** %4
%285 = load i32, i32* %7
%286 = load i32, i32* %8
%287 = add nsw i32 %285, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i8, i8* %284, i64 %288
store i8 %283, i8* %289
br label %290
290: ; preds = %277
%291 = load i32, i32* %8
%292 = add nsw i32 %291, 1
store i32 %292, i32* %8
br label %273
293: ; preds = %273
%294 = load i32, i32* %10
%295 = sub nsw i32 %294, 1
%296 = load i32, i32* %7
%297 = add nsw i32 %296, %295
store i32 %297, i32* %7
br label %298
298: ; preds = %306, %293
%299 = load i32, i32* %7
%300 = icmp slt i32 %299, 80
br i1 %300, label %301, label %309
301: ; preds = %298
%302 = load i8*, i8** %4
%303 = load i32, i32* %7
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i8, i8* %302, i64 %304
store i8 32, i8* %305
br label %306
306: ; preds = %301
%307 = load i32, i32* %7
%308 = add nsw i32 %307, 1
store i32 %308, i32* %7
br label %298
309: ; preds = %298
br label %310
310: ; preds = %309, %271
br label %311
311: ; preds = %310, %218
br label %312
312: ; preds = %311, %165
br label %313
313: ; preds = %312, %115
br label %331
314: ; preds = %41
%315 = load i8*, i8** %6
%316 = call i32 @strlen(i8* %315)
store i32 %316, i32* %7
br label %317
317: ; preds = %327, %314
%318 = load i32, i32* %7
%319 = load i8*, i8** %5
%320 = call i32 @strlen(i8* %319)
%321 = icmp slt i32 %318, %320
br i1 %321, label %322, label %330
322: ; preds = %317
%323 = load i8*, i8** %4
%324 = load i32, i32* %7
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i8, i8* %323, i64 %325
store i8 32, i8* %326
br label %327
327: ; preds = %322
%328 = load i32, i32* %7
%329 = add nsw i32 %328, 1
store i32 %329, i32* %7
br label %317
330: ; preds = %317
br label %331
331: ; preds = %330, %313
ret void
}

LLVM IR (-O2):
@.str.1 = [3 x i8] c"RA\00"
@.str.2 = [19 x i8] c" %-29.29s %-40.40s\00"
@.str.3 = [18 x i8] c"/ Right Ascension\00"
@.str.4 = [4 x i8] c"DEC\00"
@.str.5 = [14 x i8] c"/ Declination\00"
@.str.6 = [3 x i8] c"UT\00"
@.str.7 = [5 x i8] c"/ UT\00"
@.str.8 = [3 x i8] c"ST\00"
@.str.9 = [5 x i8] c"/ ST\00"
define void @search_rep(i8* %0, i8* %1, i8* %2) {
%4 = alloca [81 x i8]
%5 = alloca [81 x i8]
%6 = getelementptr inbounds [81 x i8], [81 x i8]* %4, i64 0, i64 0
%7 = getelementptr inbounds [81 x i8], [81 x i8]* %5, i64 0, i64 0
%8 = tail call i8* bitcast (i8* (i8*, i8)* @strchr to i8* (i8*, i32)*)(i8* %0, i32 61)
%9 = ptrtoint i8* %8 to i64
%10 = ptrtoint i8* %0 to i64
%11 = sub i64 %10, %9
%12 = trunc i64 %11 to i32
%13 = add i32 %12, 80
%14 = tail call i32 @strlen(i8* %2)
%15 = icmp sgt i32 %14, 0
br i1 %15, label %16, label %29
16: ; preds = %3, %16
%17 = phi i64 [ %21, %16 ], [ 0, %3 ]
%18 = getelementptr inbounds i8, i8* %2, i64 %17
%19 = load i8, i8* %18
%20 = getelementptr inbounds i8, i8* %0, i64 %17
store i8 %19, i8* %20
%21 = add nuw nsw i64 %17, 1
%22 = tail call i32 @strlen(i8* %2)
%23 = sext i32 %22 to i64
%24 = icmp slt i64 %21, %23
br i1 %24, label %16, label %25
25: ; preds = %16
%26 = trunc i64 %21 to i32
%27 = tail call i32 @strlen(i8* %2)
%28 = icmp slt i32 %27, 9
br i1 %28, label %32, label %309
29: ; preds = %3
%30 = tail call i32 @strlen(i8* %2)
%31 = icmp slt i32 %30, 9
br i1 %31, label %34, label %309
32: ; preds = %25
%33 = icmp ult i32 %26, 8
br i1 %33, label %34, label %41
34: ; preds = %29, %32
%35 = phi i32 [ %26, %32 ], [ 0, %29 ]
%36 = zext i32 %35 to i64
%37 = getelementptr i8, i8* %0, i64 %36
%38 = sub nuw nsw i32 7, %35
%39 = zext i32 %38 to i64
%40 = add nuw nsw i64 %39, 1
br label %41
41: ; preds = %34, %32
%42 = phi i32 [ %26, %32 ], [ 8, %34 ]
%43 = zext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %0, i64 %43
store i8 61, i8* %44
%45 = add nuw nsw i32 %42, 1
%46 = tail call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %74
48: ; preds = %41
%49 = getelementptr inbounds i8, i8* %8, i64 2
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 39
br i1 %51, label %322, label %52
52: ; preds = %48
%53 = zext i32 %45 to i64
%54 = getelementptr inbounds i8, i8* %0, i64 %53
%55 = tail call i8* @strchr(i8* %54, i8 signext 47)
%56 = icmp eq i8* %55, null
br i1 %56, label %64, label %57
57: ; preds = %52
%58 = getelementptr inbounds i8, i8* %0, i64 80
%59 = ptrtoint i8* %58 to i64
%60 = ptrtoint i8* %55 to i64
%61 = sub i64 %59, %60
%62 = trunc i64 %61 to i32
%63 = call i32 @strncpy(i8* %7, i8* %55, i32 %62)
br label %64
64: ; preds = %57, %52
%65 = phi i8* [ %7, %57 ], [ getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), %52 ]
%66 = getelementptr inbounds i8, i8* %8, i64 1
%67 = call i32 @atof(i8* %66)
%68 = sitofp i32 %67 to double
%69 = fdiv double %68, 1.500000e+01
%70 = fptosi double %69 to i32
%71 = call i8* @convert_deg_to_str(i32 %70)
%72 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %71, i8* %65)
%73 = call i32 @memcpy(i8* %54, i8* %6, i32 71)
br label %322
74: ; preds = %41
%75 = tail call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0))
%76 = icmp eq i32 %75, 0
br i1 %76, label %77, label %100
77: ; preds = %74
%78 = getelementptr inbounds i8, i8* %8, i64 2
%79 = load i8, i8* %78
%80 = icmp eq i8 %79, 39
br i1 %80, label %322, label %81
81: ; preds = %77
%82 = zext i32 %45 to i64
%83 = getelementptr inbounds i8, i8* %0, i64 %82
%84 = tail call i8* @strchr(i8* %83, i8 signext 47)
%85 = icmp eq i8* %84, null
br i1 %85, label %93, label %86
86: ; preds = %81
%87 = getelementptr inbounds i8, i8* %0, i64 80
%88 = ptrtoint i8* %87 to i64
%89 = ptrtoint i8* %84 to i64
%90 = sub i64 %88, %89
%91 = trunc i64 %90 to i32
%92 = call i32 @strncpy(i8* %7, i8* %84, i32 %91)
br label %93
93: ; preds = %86, %81
%94 = phi i8* [ %7, %86 ], [ getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), %81 ]
%95 = getelementptr inbounds i8, i8* %8, i64 1
%96 = call i32 @atof(i8* %95)
%97 = call i8* @convert_deg_to_str(i32 %96)
%98 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %97, i8* %94)
%99 = call i32 @memcpy(i8* %83, i8* %6, i32 71)
br label %322
100: ; preds = %74
%101 = tail call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%102 = icmp eq i32 %101, 0
br i1 %102, label %103, label %129
103: ; preds = %100
%104 = getelementptr inbounds i8, i8* %8, i64 2
%105 = load i8, i8* %104
%106 = icmp eq i8 %105, 39
br i1 %106, label %322, label %107
107: ; preds = %103
%108 = zext i32 %45 to i64
%109 = getelementptr inbounds i8, i8* %0, i64 %108
%110 = tail call i8* @strchr(i8* %109, i8 signext 47)
%111 = icmp eq i8* %110, null
br i1 %111, label %119, label %112
112: ; preds = %107
%113 = getelementptr inbounds i8, i8* %0, i64 80
%114 = ptrtoint i8* %113 to i64
%115 = ptrtoint i8* %110 to i64
%116 = sub i64 %114, %115
%117 = trunc i64 %116 to i32
%118 = call i32 @strncpy(i8* %7, i8* %110, i32 %117)
br label %119
119: ; preds = %112, %107
%120 = phi i8* [ %7, %112 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), %107 ]
%121 = getelementptr inbounds i8, i8* %8, i64 1
%122 = call i32 @atof(i8* %121)
%123 = sitofp i32 %122 to double
%124 = fdiv double %123, 3.600000e+03
%125 = fptosi double %124 to i32
%126 = call i8* @convert_deg_to_str(i32 %125)
%127 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %126, i8* %120)
%128 = call i32 @memcpy(i8* %109, i8* %6, i32 71)
br label %322
129: ; preds = %100
%130 = tail call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%131 = icmp eq i32 %130, 0
br i1 %131, label %246, label %132
132: ; preds = %129
%133 = icmp sgt i32 %13, 0
br i1 %133, label %134, label %295
134: ; preds = %132
%135 = zext i32 %45 to i64
%136 = zext i32 %13 to i64
%137 = icmp ult i32 %13, 8
br i1 %137, label %227, label %138
138: ; preds = %134
%139 = getelementptr i8, i8* %0, i64 %135
%140 = add nuw nsw i64 %135, %136
%141 = getelementptr i8, i8* %0, i64 %140
%142 = getelementptr i8, i8* %8, i64 1
%143 = add nuw nsw i64 %136, 1
%144 = getelementptr i8, i8* %8, i64 %143
%145 = icmp ult i8* %139, %144
%146 = icmp ult i8* %142, %141
%147 = and i1 %145, %146
br i1 %147, label %227, label %148
148: ; preds = %138
%149 = icmp ult i32 %13, 32
br i1 %149, label %211, label %150
150: ; preds = %148
%151 = and i64 %136, 4294967264
%152 = add nsw i64 %151, -32
%153 = lshr exact i64 %152, 5
%154 = add nuw nsw i64 %153, 1
%155 = and i64 %154, 1
%156 = icmp eq i64 %152, 0
br i1 %156, label %190, label %157
157: ; preds = %150
%158 = and i64 %154, 1152921504606846974
br label %159
159: ; preds = %159, %157
%160 = phi i64 [ 0, %157 ], [ %187, %159 ]
%161 = phi i64 [ 0, %157 ], [ %188, %159 ]
%162 = or i64 %160, 1
%163 = getelementptr inbounds i8, i8* %8, i64 %162
%164 = bitcast i8* %163 to <16 x i8>*
%165 = load <16 x i8>, <16 x i8>* %164
%166 = getelementptr inbounds i8, i8* %163, i64 16
%167 = bitcast i8* %166 to <16 x i8>*
%168 = load <16 x i8>, <16 x i8>* %167
%169 = add nuw nsw i64 %160, %135
%170 = getelementptr inbounds i8, i8* %0, i64 %169
%171 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %165, <16 x i8>* %171
%172 = getelementptr inbounds i8, i8* %170, i64 16
%173 = bitcast i8* %172 to <16 x i8>*
store <16 x i8> %168, <16 x i8>* %173
%174 = or i64 %160, 32
%175 = or i64 %160, 33
%176 = getelementptr inbounds i8, i8* %8, i64 %175
%177 = bitcast i8* %176 to <16 x i8>*
%178 = load <16 x i8>, <16 x i8>* %177
%179 = getelementptr inbounds i8, i8* %176, i64 16
%180 = bitcast i8* %179 to <16 x i8>*
%181 = load <16 x i8>, <16 x i8>* %180
%182 = add nuw nsw i64 %174, %135
%183 = getelementptr inbounds i8, i8* %0, i64 %182
%184 = bitcast i8* %183 to <16 x i8>*
store <16 x i8> %178, <16 x i8>* %184
%185 = getelementptr inbounds i8, i8* %183, i64 16
%186 = bitcast i8* %185 to <16 x i8>*
store <16 x i8> %181, <16 x i8>* %186
%187 = add nuw i64 %160, 64
%188 = add i64 %161, 2
%189 = icmp eq i64 %188, %158
br i1 %189, label %190, label %159
190: ; preds = %159, %150
%191 = phi i64 [ 0, %150 ], [ %187, %159 ]
%192 = icmp eq i64 %155, 0
br i1 %192, label %206, label %193
193: ; preds = %190
%194 = or i64 %191, 1
%195 = getelementptr inbounds i8, i8* %8, i64 %194
%196 = bitcast i8* %195 to <16 x i8>*
%197 = load <16 x i8>, <16 x i8>* %196
%198 = getelementptr inbounds i8, i8* %195, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
%200 = load <16 x i8>, <16 x i8>* %199
%201 = add nuw nsw i64 %191, %135
%202 = getelementptr inbounds i8, i8* %0, i64 %201
%203 = bitcast i8* %202 to <16 x i8>*
store <16 x i8> %197, <16 x i8>* %203
%204 = getelementptr inbounds i8, i8* %202, i64 16
%205 = bitcast i8* %204 to <16 x i8>*
store <16 x i8> %200, <16 x i8>* %205
br label %206
206: ; preds = %190, %193
%207 = icmp eq i64 %151, %136
br i1 %207, label %295, label %208
208: ; preds = %206
%209 = and i64 %136, 24
%210 = icmp eq i64 %209, 0
br i1 %210, label %227, label %211
211: ; preds = %148, %208
%212 = phi i64 [ %151, %208 ], [ 0, %148 ]
%213 = and i64 %136, 4294967288
br label %214
214: ; preds = %214, %211
%215 = phi i64 [ %212, %211 ], [ %223, %214 ]
%216 = or i64 %215, 1
%217 = getelementptr inbounds i8, i8* %8, i64 %216
%218 = bitcast i8* %217 to <8 x i8>*
%219 = load <8 x i8>, <8 x i8>* %218
%220 = add nuw nsw i64 %215, %135
%221 = getelementptr inbounds i8, i8* %0, i64 %220
%222 = bitcast i8* %221 to <8 x i8>*
store <8 x i8> %219, <8 x i8>* %222
%223 = add nuw i64 %215, 8
%224 = icmp eq i64 %223, %213
br i1 %224, label %225, label %214
225: ; preds = %214
%226 = icmp eq i64 %213, %136
br i1 %226, label %295, label %227
227: ; preds = %138, %134, %208, %225
%228 = phi i64 [ 0, %134 ], [ 0, %138 ], [ %151, %208 ], [ %213, %225 ]
%229 = xor i64 %228, -1
%230 = add nsw i64 %229, %136
%231 = and i64 %136, 3
%232 = icmp eq i64 %231, 0
br i1 %232, label %243, label %233
233: ; preds = %227, %233
%234 = phi i64 [ %236, %233 ], [ %228, %227 ]
%235 = phi i64 [ %241, %233 ], [ 0, %227 ]
%236 = add nuw nsw i64 %234, 1
%237 = getelementptr inbounds i8, i8* %8, i64 %236
%238 = load i8, i8* %237
%239 = add nuw nsw i64 %234, %135
%240 = getelementptr inbounds i8, i8* %0, i64 %239
store i8 %238, i8* %240
%241 = add i64 %235, 1
%242 = icmp eq i64 %241, %231
br i1 %242, label %243, label %233
243: ; preds = %233, %227
%244 = phi i64 [ %228, %227 ], [ %236, %233 ]
%245 = icmp ult i64 %230, 3
br i1 %245, label %295, label %272
246: ; preds = %129
%247 = getelementptr inbounds i8, i8* %8, i64 2
%248 = load i8, i8* %247
%249 = icmp eq i8 %248, 39
br i1 %249, label %322, label %250
250: ; preds = %246
%251 = zext i32 %45 to i64
%252 = getelementptr inbounds i8, i8* %0, i64 %251
%253 = tail call i8* @strchr(i8* %252, i8 signext 47)
%254 = icmp eq i8* %253, null
br i1 %254, label %262, label %255
255: ; preds = %250
%256 = getelementptr inbounds i8, i8* %0, i64 80
%257 = ptrtoint i8* %256 to i64
%258 = ptrtoint i8* %253 to i64
%259 = sub i64 %257, %258
%260 = trunc i64 %259 to i32
%261 = call i32 @strncpy(i8* %7, i8* %253, i32 %260)
br label %262
262: ; preds = %255, %250
%263 = phi i8* [ %7, %255 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), %250 ]
%264 = getelementptr inbounds i8, i8* %8, i64 1
%265 = call i32 @atof(i8* %264)
%266 = sitofp i32 %265 to double
%267 = fdiv double %266, 3.600000e+03
%268 = fptosi double %267 to i32
%269 = call i8* @convert_deg_to_str(i32 %268)
%270 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i8* %269, i8* %263)
%271 = call i32 @memcpy(i8* %252, i8* %6, i32 71)
br label %322
272: ; preds = %243, %272
%273 = phi i64 [ %289, %272 ], [ %244, %243 ]
%274 = add nuw nsw i64 %273, 1
%275 = getelementptr inbounds i8, i8* %8, i64 %274
%276 = load i8, i8* %275
%277 = add nuw nsw i64 %273, %135
%278 = getelementptr inbounds i8, i8* %0, i64 %277
store i8 %276, i8* %278
%279 = add nuw nsw i64 %273, 2
%280 = getelementptr inbounds i8, i8* %8, i64 %279
%281 = load i8, i8* %280
%282 = add nuw nsw i64 %274, %135
%283 = getelementptr inbounds i8, i8* %0, i64 %282
store i8 %281, i8* %283
%284 = add nuw nsw i64 %273, 3
%285 = getelementptr inbounds i8, i8* %8, i64 %284
%286 = load i8, i8* %285
%287 = add nuw nsw i64 %279, %135
%288 = getelementptr inbounds i8, i8* %0, i64 %287
store i8 %286, i8* %288
%289 = add nuw nsw i64 %273, 4
%290 = getelementptr inbounds i8, i8* %8, i64 %289
%291 = load i8, i8* %290
%292 = add nuw nsw i64 %284, %135
%293 = getelementptr inbounds i8, i8* %0, i64 %292
store i8 %291, i8* %293
%294 = icmp eq i64 %289, %136
br i1 %294, label %295, label %272
295: ; preds = %243, %272, %206, %225, %132
%296 = add i32 %12, 79
%297 = add i32 %296, %45
%298 = icmp slt i32 %297, 80
br i1 %298, label %299, label %322
299: ; preds = %295
%300 = sext i32 %297 to i64
%301 = getelementptr i8, i8* %0, i64 %300
%302 = trunc i64 %9 to i32
%303 = xor i32 %42, -1
%304 = add i32 %303, %302
%305 = trunc i64 %10 to i32
%306 = sub i32 %304, %305
%307 = zext i32 %306 to i64
%308 = add nuw nsw i64 %307, 1
br label %322
309: ; preds = %29, %25
%310 = tail call i32 @strlen(i8* %2)
%311 = tail call i32 @strlen(i8* %1)
%312 = icmp slt i32 %310, %311
br i1 %312, label %313, label %322
313: ; preds = %309
%314 = sext i32 %310 to i64
br label %315
315: ; preds = %313, %315
%316 = phi i64 [ %314, %313 ], [ %318, %315 ]
%317 = getelementptr inbounds i8, i8* %0, i64 %316
store i8 32, i8* %317
%318 = add nsw i64 %316, 1
%319 = tail call i32 @strlen(i8* %1)
%320 = sext i32 %319 to i64
%321 = icmp slt i64 %318, %320
br i1 %321, label %315, label %322
322: ; preds = %315, %299, %309, %295, %64, %48, %119, %103, %246, %262, %77, %93
ret void
}