#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 strlen(char *);
void utilStrInsertChars(char *str, char *chars) {
  int cnt = strlen(chars);
  char *str2 = str;
  while (*str2++)
    ;
  while (str2-- != str)
    *(str2 + cnt) = *str2;
  while (*chars)
    *str++ = *chars++;
}


x86 assembly (clang, -O0):
<utilStrInsertChars>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
cmpb   $0x0,(%rax)
je     1151 <utilStrInsertChars+0x41>
jmp    1134 <utilStrInsertChars+0x24>
jmp    1156 <utilStrInsertChars+0x46>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    -0x8(%rbp),%rax
je     1185 <utilStrInsertChars+0x75>
mov    -0x20(%rbp),%rax
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1156 <utilStrInsertChars+0x46>
jmp    118a <utilStrInsertChars+0x7a>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     11be <utilStrInsertChars+0xae>
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    118a <utilStrInsertChars+0x7a>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<utilStrInsertChars>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rsi,%rdi
call   1030 <strlen@plt>
mov    $0xffffffffffffffff,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
cmpb   $0x0,(%rbx,%rcx,1)
lea    0x1(%rcx),%rcx
jne    1140 <utilStrInsertChars+0x30>
test   %rcx,%rcx
je     120c <utilStrInsertChars+0xfc>
movslq %eax,%rbp
lea    (%rbx,%rbp,1),%rdi
movb   $0x0,-0x1(%rcx,%rdi,1)
cmp    $0x1,%rcx
je     120c <utilStrInsertChars+0xfc>
lea    -0x1(%rcx),%r12
lea    (%rbx,%rcx,1),%rsi
add    $0xfffffffffffffffe,%rsi
cmp    $0x4,%r12
jae    1240 <utilStrInsertChars+0x130>
mov    %esi,%edx
sub    %ebx,%edx
add    $0x1,%edx
mov    %rsi,%rcx
sub    %rbx,%rcx
and    $0x7,%rdx
je     11b0 <utilStrInsertChars+0xa0>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rsi),%eax
mov    %al,(%rsi,%rbp,1)
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffff,%rdx
jne    11a0 <utilStrInsertChars+0x90>
cmp    $0x7,%rcx
jb     120c <utilStrInsertChars+0xfc>
add    $0x1,%rsi
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rsi),%eax
mov    %al,-0x1(%rsi,%rbp,1)
movzbl -0x2(%rsi),%eax
mov    %al,-0x2(%rsi,%rbp,1)
movzbl -0x3(%rsi),%eax
mov    %al,-0x3(%rsi,%rbp,1)
movzbl -0x4(%rsi),%eax
mov    %al,-0x4(%rsi,%rbp,1)
movzbl -0x5(%rsi),%eax
mov    %al,-0x5(%rsi,%rbp,1)
movzbl -0x6(%rsi),%eax
mov    %al,-0x6(%rsi,%rbp,1)
movzbl -0x7(%rsi),%eax
mov    %al,-0x7(%rsi,%rbp,1)
movzbl -0x8(%rsi),%eax
mov    %al,-0x8(%rsi,%rbp,1)
lea    -0x8(%rsi),%rax
mov    %rax,%rsi
cmp    %rbx,%rax
jne    11c0 <utilStrInsertChars+0xb0>
mov    (%r14),%al
test   %al,%al
je     1231 <utilStrInsertChars+0x121>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %al,(%rbx,%rcx,1)
movzbl 0x1(%r14,%rcx,1),%eax
add    $0x1,%rcx
test   %al,%al
jne    1220 <utilStrInsertChars+0x110>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rcx,%rdi,1),%r11
add    $0xfffffffffffffffe,%r11
add    %rcx,%rdi
mov    $0x2,%r10d
sub    %rcx,%r10
lea    (%r10,%rdi,1),%r9
add    $0xfffffffffffffffe,%r9
cmp    %r11,%r9
ja     1183 <utilStrInsertChars+0x73>
add    %rsi,%r10
cmp    %rsi,%r10
ja     1183 <utilStrInsertChars+0x73>
lea    (%rbx,%rcx,1),%rdi
add    $0xffffffffffffffff,%rdi
mov    %rbp,%rax
sub    %rcx,%rax
add    %rdi,%rax
add    $0x1,%rax
cmp    %rdi,%rax
jae    12a3 <utilStrInsertChars+0x193>
lea    (%r9,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
sub    %rcx,%rdi
add    $0x1,%rdi
cmp    %rax,%rdi
jb     1183 <utilStrInsertChars+0x73>
cmp    $0x10,%r12
jae    12b1 <utilStrInsertChars+0x1a1>
xor    %r8d,%r8d
jmp    1390 <utilStrInsertChars+0x280>
mov    %r12,%r8
and    $0xfffffffffffffff0,%r8
lea    -0x10(%r8),%rax
mov    %rax,%r11
shr    $0x4,%r11
add    $0x1,%r11
cmp    $0x30,%rax
jae    12d5 <utilStrInsertChars+0x1c5>
mov    %r12,%rdi
xor    %r15d,%r15d
jmp    132d <utilStrInsertChars+0x21d>
mov    %r12,%rdi
and    $0xfffffffffffffff0,%r12
add    $0xfffffffffffffff0,%r12
shr    $0x4,%r12
add    $0x1,%r12
and    $0xfffffffffffffffc,%r12
xor    %r15d,%r15d
nop
lea    (%r10,%r15,1),%rax
movups -0x11(%rcx,%rax,1),%xmm0
lea    (%r9,%r15,1),%rsi
movups %xmm0,-0x11(%rcx,%rsi,1)
movups -0x21(%rcx,%rax,1),%xmm0
movups %xmm0,-0x21(%rcx,%rsi,1)
movups -0x31(%rcx,%rax,1),%xmm0
movups %xmm0,-0x31(%rcx,%rsi,1)
movups -0x41(%rcx,%rax,1),%xmm0
movups %xmm0,-0x41(%rcx,%rsi,1)
add    $0xffffffffffffffc0,%r15
add    $0xfffffffffffffffc,%r12
jne    12f0 <utilStrInsertChars+0x1e0>
neg    %r15
test   $0x3,%r11b
je     137e <utilStrInsertChars+0x26e>
mov    %edi,%eax
and    $0x30,%al
add    $0xf0,%al
shr    $0x4,%al
add    $0x1,%al
movzbl %al,%r11d
and    $0x3,%r11d
shl    $0x4,%r11
mov    %r10,%r12
sub    %r15,%r12
mov    %r9,%r13
sub    %r15,%r13
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    (%r12,%rsi,1),%rax
movups -0x11(%rcx,%rax,1),%xmm0
lea    (%rsi,%r13,1),%rax
movups %xmm0,-0x11(%rcx,%rax,1)
add    $0xfffffffffffffff0,%rsi
mov    %r11,%rax
add    %rsi,%rax
jne    1360 <utilStrInsertChars+0x250>
cmp    %r8,%rdi
je     120c <utilStrInsertChars+0xfc>
mov    %rdi,%r12
test   $0xc,%r12b
je     13eb <utilStrInsertChars+0x2db>
mov    %r12,%r11
and    $0xfffffffffffffffc,%r11
and    $0xfffffffffffffffc,%rdx
mov    %r10,%rax
sub    %rdx,%rax
lea    (%rax,%rcx,1),%rsi
add    $0xfffffffffffffffe,%rsi
mov    %rbp,%rdx
sub    %r8,%rdx
neg    %r8
add    $0xfffffffffffffffb,%rdx
mov    %r11,%r15
neg    %r15
nopl   0x0(%rax)
lea    (%r10,%r8,1),%rax
mov    -0x5(%rcx,%rax,1),%eax
lea    (%r9,%r8,1),%rdi
mov    %eax,-0x5(%rcx,%rdi,1)
add    $0xfffffffffffffffc,%r8
add    $0xfffffffffffffffc,%rdx
cmp    %r8,%r15
jne    13c0 <utilStrInsertChars+0x2b0>
cmp    %r11,%r12
jne    1183 <utilStrInsertChars+0x73>
jmp    120c <utilStrInsertChars+0xfc>
and    $0xfffffffffffffff0,%rdx
sub    %rdx,%r10
lea    (%r10,%rcx,1),%rsi
add    $0xfffffffffffffffe,%rsi
jmp    1183 <utilStrInsertChars+0x73>

LLVM IR (-O0):
define void @utilStrInsertChars(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%7 = load i8*, i8** %4
%8 = call i32 @strlen(i8* %7)
store i32 %8, i32* %5
%9 = load i8*, i8** %3
store i8* %9, i8** %6
br label %10
10: ; preds = %15, %2
%11 = load i8*, i8** %6
%12 = getelementptr inbounds i8, i8* %11, i32 1
store i8* %12, i8** %6
%13 = load i8, i8* %11
%14 = icmp ne i8 %13, 0
br i1 %14, label %15, label %16
15: ; preds = %10
br label %10
16: ; preds = %10
br label %17
17: ; preds = %22, %16
%18 = load i8*, i8** %6
%19 = getelementptr inbounds i8, i8* %18, i32 -1
store i8* %19, i8** %6
%20 = load i8*, i8** %3
%21 = icmp ne i8* %18, %20
br i1 %21, label %22, label %29
22: ; preds = %17
%23 = load i8*, i8** %6
%24 = load i8, i8* %23
%25 = load i8*, i8** %6
%26 = load i32, i32* %5
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
store i8 %24, i8* %28
br label %17
29: ; preds = %17
br label %30
30: ; preds = %34, %29
%31 = load i8*, i8** %4
%32 = load i8, i8* %31
%33 = icmp ne i8 %32, 0
br i1 %33, label %34, label %40
34: ; preds = %30
%35 = load i8*, i8** %4
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %4
%37 = load i8, i8* %35
%38 = load i8*, i8** %3
%39 = getelementptr inbounds i8, i8* %38, i32 1
store i8* %39, i8** %3
store i8 %37, i8* %38
br label %30
40: ; preds = %30
ret void
}

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