#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 cc_len(char const, char const);
char *strchr(char const *, int /*<<< orphan*/);
int /*<<< orphan*/ strcpy(char *, char *);
int encode_e164(char *buf, const char *addr) {
  const char *prefix, *here;
  prefix = addr + cc_len(addr[0] - 48, addr[1] - 48);
  here = strchr(addr, 0);
  while (here > prefix) {
    *buf++ = *--here;
    *buf++ = '.';
  }
  while (here > addr)
    *buf++ = *addr++;
  strcpy(buf, ".E164.ATMA.INT.");
  return 0;
}


x86 assembly (clang, -O0):
<encode_e164>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x30,%eax
movsbl %cl,%edi
movsbl %al,%esi
call   1050 <cc_len@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
xor    %esi,%esi
call   1040 <strchr@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jbe    11d1 <encode_e164+0xa1>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    -0x1(%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x2e,(%rax)
jmp    1189 <encode_e164+0x59>
jmp    11d6 <encode_e164+0xa6>
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    120b <encode_e164+0xdb>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    11d6 <encode_e164+0xa6>
mov    -0x8(%rbp),%rdi
lea    0xdea(%rip),%rsi
call   1030 <strcpy@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encode_e164>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
mov    (%rsi),%al
mov    0x1(%rsi),%cl
add    $0xd0,%al
add    $0xd0,%cl
movsbl %al,%edi
movsbl %cl,%esi
call   1050 <cc_len@plt>
movslq %eax,%r12
lea    (%rbx,%r12,1),%r15
mov    %rbx,%rdi
call   1040 <strlen@plt>
lea    (%rbx,%rax,1),%rcx
cmp    %r15,%rcx
jbe    11a9 <encode_e164+0x79>
mov    %rax,%r9
sub    %r12,%r9
cmp    $0x10,%r9
jb     1189 <encode_e164+0x59>
cmp    %r14,%rcx
jbe    1202 <encode_e164+0xd2>
lea    (%r14,%r9,2),%rdx
cmp    %rdx,%r15
jae    1202 <encode_e164+0xd2>
mov    %r14,%rdi
nopl   0x0(%rax)
movzbl -0x1(%rcx),%eax
add    $0xffffffffffffffff,%rcx
mov    %al,(%rdi)
movb   $0x2e,0x1(%rdi)
add    $0x2,%rdi
cmp    %r15,%rcx
ja     1190 <encode_e164+0x60>
jmp    11ac <encode_e164+0x7c>
mov    %r14,%rdi
mov    %rcx,%r9
sub    %rbx,%r9
jbe    13c3 <encode_e164+0x293>
cmp    $0x20,%r9
jb     134a <encode_e164+0x21a>
cmp    %rcx,%rdi
jae    11d4 <encode_e164+0xa4>
lea    (%rdi,%r9,1),%rax
cmp    %rbx,%rax
ja     134a <encode_e164+0x21a>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rax
mov    %rax,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0x60,%rax
jae    1297 <encode_e164+0x167>
xor    %eax,%eax
jmp    12fc <encode_e164+0x1cc>
mov    %r9,%r8
and    $0xfffffffffffffff0,%r8
mov    %r8,%rsi
neg    %rsi
sub    %r8,%rcx
lea    (%r14,%r8,2),%rdi
add    $0x10,%r14
add    %rbx,%rax
add    $0xfffffffffffffff8,%rax
xor    %edx,%edx
pxor   %xmm0,%xmm0
movdqa 0xdd1(%rip),%xmm1
nop
movq   (%rax,%rdx,1),%xmm2
movq   -0x8(%rax,%rdx,1),%xmm3
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm2,%xmm2
punpcklbw %xmm1,%xmm2
movdqu %xmm2,-0x10(%r14)
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm2,%xmm2
punpcklbw %xmm1,%xmm2
movdqu %xmm2,(%r14)
add    $0x20,%r14
add    $0xfffffffffffffff0,%rdx
cmp    %rdx,%rsi
jne    1230 <encode_e164+0x100>
cmp    %r8,%r9
jne    1190 <encode_e164+0x60>
jmp    11ac <encode_e164+0x7c>
and    $0xfffffffffffffffc,%rsi
xor    %eax,%eax
nopl   (%rax)
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
movups 0x20(%rbx,%rax,1),%xmm0
movups 0x30(%rbx,%rax,1),%xmm1
movups %xmm0,0x20(%rdi,%rax,1)
movups %xmm1,0x30(%rdi,%rax,1)
movups 0x40(%rbx,%rax,1),%xmm0
movups 0x50(%rbx,%rax,1),%xmm1
movups %xmm0,0x40(%rdi,%rax,1)
movups %xmm1,0x50(%rdi,%rax,1)
movdqu 0x60(%rbx,%rax,1),%xmm0
movdqu 0x70(%rbx,%rax,1),%xmm1
movdqu %xmm0,0x60(%rdi,%rax,1)
movdqu %xmm1,0x70(%rdi,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rsi
jne    12a0 <encode_e164+0x170>
test   %r10,%r10
je     133f <encode_e164+0x20f>
lea    (%rbx,%rax,1),%rsi
add    $0x10,%rsi
add    %rdi,%rax
add    $0x10,%rax
shl    $0x5,%r10
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rdx,1),%xmm0
movdqu (%rsi,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1320 <encode_e164+0x1f0>
add    %r8,%rdi
cmp    %r8,%r9
je     13c3 <encode_e164+0x293>
add    %r8,%rbx
mov    %ecx,%edx
sub    %ebx,%edx
mov    %rbx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x7,%rdx
je     1373 <encode_e164+0x243>
nopl   (%rax)
movzbl (%rbx),%eax
add    $0x1,%rbx
mov    %al,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1360 <encode_e164+0x230>
cmp    $0x7,%rsi
jb     13c3 <encode_e164+0x293>
nopl   0x0(%rax)
movzbl (%rbx),%eax
mov    %al,(%rdi)
movzbl 0x1(%rbx),%eax
mov    %al,0x1(%rdi)
movzbl 0x2(%rbx),%eax
mov    %al,0x2(%rdi)
movzbl 0x3(%rbx),%eax
mov    %al,0x3(%rdi)
movzbl 0x4(%rbx),%eax
mov    %al,0x4(%rdi)
movzbl 0x5(%rbx),%eax
mov    %al,0x5(%rdi)
movzbl 0x6(%rbx),%eax
mov    %al,0x6(%rdi)
movzbl 0x7(%rbx),%eax
mov    %al,0x7(%rdi)
add    $0x8,%rdi
add    $0x8,%rbx
cmp    %rcx,%rbx
jne    1380 <encode_e164+0x250>
lea    0xc46(%rip),%rsi
call   1030 <strcpy@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [16 x i8] c".E164.ATMA.INT.\00"
define i32 @encode_e164(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%7 = load i8*, i8** %4
%8 = load i8*, i8** %4
%9 = getelementptr inbounds i8, i8* %8, i64 0
%10 = load i8, i8* %9
%11 = sext i8 %10 to i32
%12 = sub nsw i32 %11, 48
%13 = trunc i32 %12 to i8
%14 = load i8*, i8** %4
%15 = getelementptr inbounds i8, i8* %14, i64 1
%16 = load i8, i8* %15
%17 = sext i8 %16 to i32
%18 = sub nsw i32 %17, 48
%19 = trunc i32 %18 to i8
%20 = call i32 @cc_len(i8 signext %13, i8 signext %19)
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %7, i64 %21
store i8* %22, i8** %5
%23 = load i8*, i8** %4
%24 = call i8* @strchr(i8* %23, i32 0)
store i8* %24, i8** %6
br label %25
25: ; preds = %29, %2
%26 = load i8*, i8** %6
%27 = load i8*, i8** %5
%28 = icmp ugt i8* %26, %27
br i1 %28, label %29, label %37
29: ; preds = %25
%30 = load i8*, i8** %6
%31 = getelementptr inbounds i8, i8* %30, i32 -1
store i8* %31, i8** %6
%32 = load i8, i8* %31
%33 = load i8*, i8** %3
%34 = getelementptr inbounds i8, i8* %33, i32 1
store i8* %34, i8** %3
store i8 %32, i8* %33
%35 = load i8*, i8** %3
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %3
store i8 46, i8* %35
br label %25
37: ; preds = %25
br label %38
38: ; preds = %42, %37
%39 = load i8*, i8** %6
%40 = load i8*, i8** %4
%41 = icmp ugt i8* %39, %40
br i1 %41, label %42, label %48
42: ; preds = %38
%43 = load i8*, i8** %4
%44 = getelementptr inbounds i8, i8* %43, i32 1
store i8* %44, i8** %4
%45 = load i8, i8* %43
%46 = load i8*, i8** %3
%47 = getelementptr inbounds i8, i8* %46, i32 1
store i8* %47, i8** %3
store i8 %45, i8* %46
br label %38
48: ; preds = %38
%49 = load i8*, i8** %3
%50 = call i32 @strcpy(i8* %49, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [16 x i8] c".E164.ATMA.INT.\00"
define i32 @encode_e164(i8* %0, i8* %1) {
%3 = ptrtoint i8* %1 to i64
%4 = load i8, i8* %1
%5 = add i8 %4, -48
%6 = getelementptr inbounds i8, i8* %1, i64 1
%7 = load i8, i8* %6
%8 = add i8 %7, -48
%9 = tail call i32 @cc_len(i8 signext %5, i8 signext %8)
%10 = sext i32 %9 to i64
%11 = getelementptr i8, i8* %1, i64 %10
%12 = tail call i64 @strlen(i8* %1)
%13 = getelementptr i8, i8* %1, i64 %12
%14 = icmp ugt i8* %13, %11
br i1 %14, label %15, label %61
15: ; preds = %2
%16 = sub i64 %12, %10
%17 = icmp ult i64 %16, 16
br i1 %17, label %58, label %18
18: ; preds = %15
%19 = sub i64 %12, %10
%20 = shl i64 %19, 1
%21 = getelementptr i8, i8* %0, i64 %20
%22 = icmp ugt i8* %13, %0
%23 = icmp ult i8* %11, %21
%24 = and i1 %22, %23
br i1 %24, label %58, label %25
25: ; preds = %18
%26 = and i64 %16, -16
%27 = sub i64 0, %26
%28 = getelementptr i8, i8* %13, i64 %27
%29 = shl i64 %26, 1
%30 = getelementptr i8, i8* %0, i64 %29
%31 = getelementptr i8, i8* %13, i64 -1
br label %32
32: ; preds = %32, %25
%33 = phi i64 [ 0, %25 ], [ %54, %32 ]
%34 = sub i64 0, %33
%35 = shl i64 %33, 1
%36 = shl i64 %33, 1
%37 = or i64 %36, 16
%38 = getelementptr inbounds i8, i8* %31, i64 %34
%39 = getelementptr inbounds i8, i8* %38, i64 -7
%40 = bitcast i8* %39 to <8 x i8>*
%41 = load <8 x i8>, <8 x i8>* %40
%42 = shufflevector <8 x i8> %41, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%43 = getelementptr inbounds i8, i8* %38, i64 -8
%44 = getelementptr inbounds i8, i8* %43, i64 -7
%45 = bitcast i8* %44 to <8 x i8>*
%46 = load <8 x i8>, <8 x i8>* %45
%47 = shufflevector <8 x i8> %46, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%48 = getelementptr inbounds i8, i8* %0, i64 %35
%49 = bitcast i8* %48 to <16 x i8>*
%50 = getelementptr inbounds i8, i8* %0, i64 %37
%51 = bitcast i8* %50 to <16 x i8>*
%52 = shufflevector <8 x i8> %42, <8 x i8> <i8 46, i8 46, i8 46, i8 46, i8 46, i8 46, i8 46, i8 46>, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %52, <16 x i8>* %49
%53 = shufflevector <8 x i8> %47, <8 x i8> <i8 46, i8 46, i8 46, i8 46, i8 46, i8 46, i8 46, i8 46>, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %53, <16 x i8>* %51
%54 = add nuw i64 %33, 16
%55 = icmp eq i64 %54, %26
br i1 %55, label %56, label %32
56: ; preds = %32
%57 = icmp eq i64 %16, %26
br i1 %57, label %61, label %58
58: ; preds = %18, %15, %56
%59 = phi i8* [ %13, %18 ], [ %13, %15 ], [ %28, %56 ]
%60 = phi i8* [ %0, %18 ], [ %0, %15 ], [ %30, %56 ]
br label %179
61: ; preds = %179, %56, %2
%62 = phi i8* [ %0, %2 ], [ %30, %56 ], [ %185, %179 ]
%63 = phi i8* [ %13, %2 ], [ %28, %56 ], [ %182, %179 ]
%64 = icmp ugt i8* %63, %1
br i1 %64, label %65, label %215
65: ; preds = %61
%66 = ptrtoint i8* %63 to i64
%67 = sub i64 %66, %3
%68 = getelementptr i8, i8* %1, i64 %67
%69 = icmp ult i64 %67, 32
br i1 %69, label %156, label %70
70: ; preds = %65
%71 = getelementptr i8, i8* %62, i64 %67
%72 = icmp ult i8* %62, %68
%73 = icmp ugt i8* %71, %1
%74 = and i1 %72, %73
br i1 %74, label %156, label %75
75: ; preds = %70
%76 = and i64 %67, -32
%77 = getelementptr i8, i8* %62, i64 %76
%78 = getelementptr i8, i8* %1, i64 %76
%79 = add i64 %76, -32
%80 = lshr exact i64 %79, 5
%81 = add nuw nsw i64 %80, 1
%82 = and i64 %81, 3
%83 = icmp ult i64 %79, 96
br i1 %83, label %135, label %84
84: ; preds = %75
%85 = and i64 %81, 1152921504606846972
br label %86
86: ; preds = %86, %84
%87 = phi i64 [ 0, %84 ], [ %132, %86 ]
%88 = phi i64 [ 0, %84 ], [ %133, %86 ]
%89 = getelementptr i8, i8* %62, i64 %87
%90 = getelementptr i8, i8* %1, i64 %87
%91 = bitcast i8* %90 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = getelementptr i8, i8* %90, i64 16
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = bitcast i8* %89 to <16 x i8>*
store <16 x i8> %92, <16 x i8>* %96
%97 = getelementptr i8, i8* %89, i64 16
%98 = bitcast i8* %97 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %98
%99 = or i64 %87, 32
%100 = getelementptr i8, i8* %62, i64 %99
%101 = getelementptr i8, i8* %1, i64 %99
%102 = bitcast i8* %101 to <16 x i8>*
%103 = load <16 x i8>, <16 x i8>* %102
%104 = getelementptr i8, i8* %101, i64 16
%105 = bitcast i8* %104 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %103, <16 x i8>* %107
%108 = getelementptr i8, i8* %100, i64 16
%109 = bitcast i8* %108 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %109
%110 = or i64 %87, 64
%111 = getelementptr i8, i8* %62, i64 %110
%112 = getelementptr i8, i8* %1, i64 %110
%113 = bitcast i8* %112 to <16 x i8>*
%114 = load <16 x i8>, <16 x i8>* %113
%115 = getelementptr i8, i8* %112, i64 16
%116 = bitcast i8* %115 to <16 x i8>*
%117 = load <16 x i8>, <16 x i8>* %116
%118 = bitcast i8* %111 to <16 x i8>*
store <16 x i8> %114, <16 x i8>* %118
%119 = getelementptr i8, i8* %111, i64 16
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %117, <16 x i8>* %120
%121 = or i64 %87, 96
%122 = getelementptr i8, i8* %62, i64 %121
%123 = getelementptr i8, i8* %1, i64 %121
%124 = bitcast i8* %123 to <16 x i8>*
%125 = load <16 x i8>, <16 x i8>* %124
%126 = getelementptr i8, i8* %123, i64 16
%127 = bitcast i8* %126 to <16 x i8>*
%128 = load <16 x i8>, <16 x i8>* %127
%129 = bitcast i8* %122 to <16 x i8>*
store <16 x i8> %125, <16 x i8>* %129
%130 = getelementptr i8, i8* %122, i64 16
%131 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %128, <16 x i8>* %131
%132 = add nuw i64 %87, 128
%133 = add i64 %88, 4
%134 = icmp eq i64 %133, %85
br i1 %134, label %135, label %86
135: ; preds = %86, %75
%136 = phi i64 [ 0, %75 ], [ %132, %86 ]
%137 = icmp eq i64 %82, 0
br i1 %137, label %154, label %138
138: ; preds = %135, %138
%139 = phi i64 [ %151, %138 ], [ %136, %135 ]
%140 = phi i64 [ %152, %138 ], [ 0, %135 ]
%141 = getelementptr i8, i8* %62, i64 %139
%142 = getelementptr i8, i8* %1, i64 %139
%143 = bitcast i8* %142 to <16 x i8>*
%144 = load <16 x i8>, <16 x i8>* %143
%145 = getelementptr i8, i8* %142, i64 16
%146 = bitcast i8* %145 to <16 x i8>*
%147 = load <16 x i8>, <16 x i8>* %146
%148 = bitcast i8* %141 to <16 x i8>*
store <16 x i8> %144, <16 x i8>* %148
%149 = getelementptr i8, i8* %141, i64 16
%150 = bitcast i8* %149 to <16 x i8>*
store <16 x i8> %147, <16 x i8>* %150
%151 = add nuw i64 %139, 32
%152 = add i64 %140, 1
%153 = icmp eq i64 %152, %82
br i1 %153, label %154, label %138
154: ; preds = %138, %135
%155 = icmp eq i64 %67, %76
br i1 %155, label %215, label %156
156: ; preds = %70, %65, %154
%157 = phi i8* [ %62, %70 ], [ %62, %65 ], [ %77, %154 ]
%158 = phi i8* [ %1, %70 ], [ %1, %65 ], [ %78, %154 ]
%159 = ptrtoint i8* %158 to i64
%160 = sub i64 %66, %159
%161 = xor i64 %159, -1
%162 = add i64 %161, %66
%163 = and i64 %160, 7
%164 = icmp eq i64 %163, 0
br i1 %164, label %174, label %165
165: ; preds = %156, %165
%166 = phi i8* [ %171, %165 ], [ %157, %156 ]
%167 = phi i8* [ %169, %165 ], [ %158, %156 ]
%168 = phi i64 [ %172, %165 ], [ 0, %156 ]
%169 = getelementptr inbounds i8, i8* %167, i64 1
%170 = load i8, i8* %167
%171 = getelementptr inbounds i8, i8* %166, i64 1
store i8 %170, i8* %166
%172 = add i64 %168, 1
%173 = icmp eq i64 %172, %163
br i1 %173, label %174, label %165
174: ; preds = %165, %156
%175 = phi i8* [ undef, %156 ], [ %171, %165 ]
%176 = phi i8* [ %157, %156 ], [ %171, %165 ]
%177 = phi i8* [ %158, %156 ], [ %169, %165 ]
%178 = icmp ult i64 %162, 7
br i1 %178, label %215, label %187
179: ; preds = %58, %179
%180 = phi i8* [ %182, %179 ], [ %59, %58 ]
%181 = phi i8* [ %185, %179 ], [ %60, %58 ]
%182 = getelementptr inbounds i8, i8* %180, i64 -1
%183 = load i8, i8* %182
%184 = getelementptr inbounds i8, i8* %181, i64 1
store i8 %183, i8* %181
%185 = getelementptr inbounds i8, i8* %181, i64 2
store i8 46, i8* %184
%186 = icmp ugt i8* %182, %11
br i1 %186, label %179, label %61
187: ; preds = %174, %187
%188 = phi i8* [ %213, %187 ], [ %176, %174 ]
%189 = phi i8* [ %211, %187 ], [ %177, %174 ]
%190 = getelementptr inbounds i8, i8* %189, i64 1
%191 = load i8, i8* %189
%192 = getelementptr inbounds i8, i8* %188, i64 1
store i8 %191, i8* %188
%193 = getelementptr inbounds i8, i8* %189, i64 2
%194 = load i8, i8* %190
%195 = getelementptr inbounds i8, i8* %188, i64 2
store i8 %194, i8* %192
%196 = getelementptr inbounds i8, i8* %189, i64 3
%197 = load i8, i8* %193
%198 = getelementptr inbounds i8, i8* %188, i64 3
store i8 %197, i8* %195
%199 = getelementptr inbounds i8, i8* %189, i64 4
%200 = load i8, i8* %196
%201 = getelementptr inbounds i8, i8* %188, i64 4
store i8 %200, i8* %198
%202 = getelementptr inbounds i8, i8* %189, i64 5
%203 = load i8, i8* %199
%204 = getelementptr inbounds i8, i8* %188, i64 5
store i8 %203, i8* %201
%205 = getelementptr inbounds i8, i8* %189, i64 6
%206 = load i8, i8* %202
%207 = getelementptr inbounds i8, i8* %188, i64 6
store i8 %206, i8* %204
%208 = getelementptr inbounds i8, i8* %189, i64 7
%209 = load i8, i8* %205
%210 = getelementptr inbounds i8, i8* %188, i64 7
store i8 %209, i8* %207
%211 = getelementptr inbounds i8, i8* %189, i64 8
%212 = load i8, i8* %208
%213 = getelementptr inbounds i8, i8* %188, i64 8
store i8 %212, i8* %210
%214 = icmp eq i8* %211, %68
br i1 %214, label %215, label %187
215: ; preds = %174, %187, %154, %61
%216 = phi i8* [ %62, %61 ], [ %77, %154 ], [ %175, %174 ], [ %213, %187 ]
%217 = tail call i32 @strcpy(i8* %216, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0))
ret i32 0
}