#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 */
scalar_t__ strlen(char const *);
void convert_name(unsigned char *name) {
  unsigned int i = 0, j = 0, all = 0;
  for (i = 0; i < (int)strlen((const char *)name); i++) {
    all = name[i];
    for (j = 0; j < (int)all; j++) {
      name[i] = name[i + 1];
      i = i + 1;
    }
    name[i] = '.';
  }
  if (i > 0) {
    name[i - 1] = '\0';
  }
}


x86 assembly (clang, -O0):
<convert_name>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%eax
cmp    %ecx,%eax
jae    11bf <convert_name+0xaf>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    11a6 <convert_name+0x96>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    116a <convert_name+0x5a>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
movb   $0x2e,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1138 <convert_name+0x28>
cmpl   $0x0,-0xc(%rbp)
jbe    11d9 <convert_name+0xc9>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert_name>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%r13
call   1030 <strlen@plt>
test   %eax,%eax
je     1422 <convert_name+0x312>
lea    0x1(%r13),%r14
xor    %r12d,%r12d
jmp    115e <convert_name+0x4e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15d,%edx
movb   $0x2e,0x0(%r13,%rdx,1)
lea    0x1(%r15),%r12d
mov    %r13,%rdi
call   1030 <strlen@plt>
cmp    %eax,%r12d
jae    1414 <convert_name+0x304>
mov    %r12d,%edx
movzbl 0x0(%r13,%rdx,1),%r9d
test   %r9d,%r9d
je     1360 <convert_name+0x250>
lea    (%r12,%r9,1),%r15d
mov    %r12d,%esi
cmp    $0x8,%r9b
jb     1370 <convert_name+0x260>
lea    -0x1(%r9),%ecx
mov    %r12d,%edi
mov    %r12d,%esi
add    %ecx,%edi
jb     1370 <convert_name+0x260>
lea    0x1(%r12),%r8d
lea    (%r12,%r9,1),%edi
mov    %r12d,%esi
cmp    %r8d,%edi
jb     1370 <convert_name+0x260>
lea    (%rdx,%r13,1),%rsi
lea    (%rcx,%r8,1),%rdi
add    %r14,%rdi
cmp    %rdi,%rsi
jae    11ce <convert_name+0xbe>
add    %rdx,%rcx
add    %r14,%rcx
lea    (%r8,%r13,1),%rdi
mov    %r12d,%esi
cmp    %rcx,%rdi
jb     1370 <convert_name+0x260>
xor    %ecx,%ecx
cmp    $0x20,%r9b
jb     131c <convert_name+0x20c>
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
movups 0x0(%r13,%r8,1),%xmm0
movups 0x10(%r13,%r8,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    $0x20,%ecx
je     130d <convert_name+0x1fd>
lea    0x20(%r12),%edx
lea    0x21(%r12),%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    $0x40,%ecx
je     130d <convert_name+0x1fd>
lea    0x40(%r12),%edx
lea    0x41(%r12),%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    $0x60,%ecx
je     130d <convert_name+0x1fd>
lea    0x60(%r12),%edx
lea    0x61(%r12),%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    $0x80,%ecx
je     130d <convert_name+0x1fd>
lea    0x80(%r12),%edx
lea    0x81(%r12),%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    $0xa0,%ecx
je     130d <convert_name+0x1fd>
lea    0xa0(%r12),%edx
lea    0xa1(%r12),%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    $0xc0,%ecx
je     130d <convert_name+0x1fd>
lea    0xc0(%r12),%edx
lea    0xc1(%r12),%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    %r9d,%ecx
je     1140 <convert_name+0x30>
test   $0x18,%r9b
je     1368 <convert_name+0x258>
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
lea    (%r12,%r8,1),%esi
mov    %ecx,%edi
sub    %r8d,%edi
add    %r12d,%ecx
nop
lea    0x1(%rcx),%edx
mov    0x0(%r13,%rdx,1),%rdx
mov    %ecx,%eax
mov    %rdx,0x0(%r13,%rax,1)
add    $0x8,%ecx
add    $0x8,%edi
jne    1330 <convert_name+0x220>
cmp    %r9d,%r8d
je     1140 <convert_name+0x30>
jmp    1370 <convert_name+0x260>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%r15d
jmp    1143 <convert_name+0x33>
add    %r12d,%ecx
mov    %ecx,%esi
nopl   (%rax)
add    %r9d,%r12d
sub    %esi,%r12d
lea    -0x1(%r12),%ecx
and    $0x3,%r12d
je     13c0 <convert_name+0x2b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rsi),%eax
movzbl 0x0(%r13,%rax,1),%edx
mov    %esi,%esi
mov    %dl,0x0(%r13,%rsi,1)
mov    %eax,%esi
add    $0xffffffff,%r12d
jne    1390 <convert_name+0x280>
cmp    $0x3,%ecx
jae    13d0 <convert_name+0x2c0>
jmp    1140 <convert_name+0x30>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%eax
cmp    $0x3,%ecx
jb     1140 <convert_name+0x30>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%ecx
movzbl 0x0(%r13,%rcx,1),%edx
mov    %eax,%esi
mov    %dl,0x0(%r13,%rsi,1)
lea    0x2(%rax),%edx
movzbl 0x0(%r13,%rdx,1),%ebx
mov    %bl,0x0(%r13,%rcx,1)
lea    0x3(%rax),%ecx
movzbl 0x0(%r13,%rcx,1),%ebx
mov    %bl,0x0(%r13,%rdx,1)
add    $0x4,%eax
movzbl 0x0(%r13,%rax,1),%edx
mov    %dl,0x0(%r13,%rcx,1)
cmp    %eax,%r15d
jne    13d0 <convert_name+0x2c0>
jmp    1140 <convert_name+0x30>
test   %r12d,%r12d
je     1422 <convert_name+0x312>
mov    %r15d,%eax
movb   $0x0,0x0(%r13,%rax,1)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @convert_name(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
store i32 0, i32* %3
br label %6
6: ; preds = %44, %1
%7 = load i32, i32* %3
%8 = load i8*, i8** %2
%9 = call i64 @strlen(i8* %8)
%10 = trunc i64 %9 to i32
%11 = icmp ult i32 %7, %10
br i1 %11, label %12, label %47
12: ; preds = %6
%13 = load i8*, i8** %2
%14 = load i32, i32* %3
%15 = zext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
%17 = load i8, i8* %16
%18 = zext i8 %17 to i32
store i32 %18, i32* %5
store i32 0, i32* %4
br label %19
19: ; preds = %36, %12
%20 = load i32, i32* %4
%21 = load i32, i32* %5
%22 = icmp ult i32 %20, %21
br i1 %22, label %23, label %39
23: ; preds = %19
%24 = load i8*, i8** %2
%25 = load i32, i32* %3
%26 = add i32 %25, 1
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %24, i64 %27
%29 = load i8, i8* %28
%30 = load i8*, i8** %2
%31 = load i32, i32* %3
%32 = zext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %30, i64 %32
store i8 %29, i8* %33
%34 = load i32, i32* %3
%35 = add i32 %34, 1
store i32 %35, i32* %3
br label %36
36: ; preds = %23
%37 = load i32, i32* %4
%38 = add i32 %37, 1
store i32 %38, i32* %4
br label %19
39: ; preds = %19
%40 = load i8*, i8** %2
%41 = load i32, i32* %3
%42 = zext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
store i8 46, i8* %43
br label %44
44: ; preds = %39
%45 = load i32, i32* %3
%46 = add i32 %45, 1
store i32 %46, i32* %3
br label %6
47: ; preds = %6
%48 = load i32, i32* %3
%49 = icmp ugt i32 %48, 0
br i1 %49, label %50, label %56
50: ; preds = %47
%51 = load i8*, i8** %2
%52 = load i32, i32* %3
%53 = sub i32 %52, 1
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %51, i64 %54
store i8 0, i8* %55
br label %56
56: ; preds = %50, %47
ret void
}

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