void lexo(char *s, int n) {
  int i, j, k;
  char temp, *s2;
  s2 = (char *)malloc(n * sizeof(char));
  for (i = (n - 1); i > 0; i--) {
    if (*(s + i) > *(s + i - 1)) {
      j = i;
      temp = *(s + i);
      *(s + i) = *(s + i - 1);
      *(s + i + 1) = temp;
      break;
    } else {
      temp = *(s + i);
      *(s + i) = *(s + i - 1);
      *(s + i - 1) = temp;
    }
  }
  if (i == 0) {
    printf("No Answer");
    return;
  } else {
    for (k = 0; k < (n - i - 1); k++) {
      *(s2 + k) = *(s + i + k + 1);
    }
    for (k = 0; k < (n - i - 1); k++) {
      *(s + i + 1 + k) = *(s2 + n - i - 1 - 1 - k);
    }
  }
  printf("%s", s);
}


x86 assembly (clang, -O0):
<lexo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movslq -0xc(%rbp),%rdi
shl    $0x0,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jle    11fa <lexo+0xda>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
movsbl -0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jle    11b3 <lexo+0x93>
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    -0x1(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x19(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,0x1(%rax,%rcx,1)
jmp    11fa <lexo+0xda>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    -0x1(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x19(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,-0x1(%rax,%rcx,1)
jmp    11ec <lexo+0xcc>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1149 <lexo+0x29>
cmpl   $0x0,-0x10(%rbp)
jne    1217 <lexo+0xf7>
lea    0xdf5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    12d5 <lexo+0x1b5>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    125e <lexo+0x13e>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    0x1(%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    121e <lexo+0xfe>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12be <lexo+0x19e>
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    -0x2(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1265 <lexo+0x145>
jmp    12c3 <lexo+0x1a3>
mov    -0x8(%rbp),%rsi
lea    0xd3c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lexo>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r15d
mov    %rdi,%r12
movslq %esi,%r14
mov    %r14,%rdi
call   1050 <malloc@plt>
lea    -0x1(%r14),%edx
cmp    $0x2,%r14d
jl     1170 <lexo+0x40>
mov    %edx,%ecx
lea    (%r12,%rcx,1),%rbp
mov    -0x1(%r12,%rcx,1),%bl
mov    (%r12,%rcx,1),%cl
cmp    %bl,%cl
jle    1195 <lexo+0x65>
mov    %edx,%edi
mov    %r15d,%esi
jmp    11cb <lexo+0x9b>
mov    %edx,%edi
mov    %r15d,%esi
test   %edx,%edx
jne    11d1 <lexo+0xa1>
lea    0xe80(%rip),%rdi
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>
mov    %r15d,%edi
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%esi
mov    %bl,0x0(%rbp)
mov    %cl,-0x1(%rbp)
cmp    $0x1,%esi
jle    1179 <lexo+0x49>
add    $0xfffffffe,%edi
mov    %edi,%ecx
lea    (%r12,%rcx,1),%rbp
movzbl -0x1(%r12,%rcx,1),%ebx
movzbl (%r12,%rcx,1),%ecx
mov    %esi,%edi
cmp    %bl,%cl
jle    11a0 <lexo+0x70>
lea    -0x1(%rsi),%edi
mov    %bl,0x0(%rbp)
mov    %cl,0x1(%rbp)
sub    %esi,%r15d
test   %r15d,%r15d
jle    1353 <lexo+0x223>
movslq %edi,%rcx
sub    %esi,%edx
add    $0x1,%rdx
mov    %rcx,(%rsp)
lea    (%r12,%rcx,1),%rbx
add    $0x1,%rbx
mov    %rax,%r13
mov    %rax,%rdi
mov    %rbx,%rsi
call   1040 <memcpy@plt>
mov    %r15d,%ebp
cmp    $0x8,%r15d
jae    1214 <lexo+0xe4>
xor    %ecx,%ecx
mov    (%rsp),%rax
jmp    1332 <lexo+0x202>
cmp    $0x20,%r15d
jae    1225 <lexo+0xf5>
xor    %ecx,%ecx
mov    (%rsp),%rax
jmp    12dc <lexo+0x1ac>
mov    %ebp,%ecx
and    $0xffffffe0,%ecx
mov    %r14,%rdx
mov    (%rsp),%rax
sub    %rax,%rdx
add    %r13,%rdx
add    $0xffffffffffffffef,%rdx
lea    (%rax,%r12,1),%rsi
add    $0x11,%rsi
xor    %edi,%edi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movdqu -0x10(%rdx),%xmm1
movdqu (%rdx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rsi,%rdi,1)
movdqu %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rdx
cmp    %rdi,%rcx
jne    1250 <lexo+0x120>
cmp    %rbp,%rcx
je     1353 <lexo+0x223>
test   $0x18,%bpl
je     1332 <lexo+0x202>
mov    %rcx,%rdx
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
mov    %r14,%rsi
sub    %rdx,%rsi
sub    %rax,%rsi
add    %r13,%rsi
add    $0xfffffffffffffff7,%rsi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movq   (%rsi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rbx,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    1300 <lexo+0x1d0>
cmp    %rbp,%rcx
je     1353 <lexo+0x223>
sub    %rcx,%r14
sub    %rax,%r14
lea    (%r14,%r13,1),%rdx
add    $0xfffffffffffffffe,%rdx
movzbl (%rdx),%eax
mov    %al,(%rbx,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rcx,%rbp
jne    1340 <lexo+0x210>
lea    0xcb0(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [10 x i8] c"No Answer\00"
@.str.1 = [3 x i8] c"%s\00"
define void @lexo(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8
%9 = alloca i8*
store i8* %0, i8** %3
store i32 %1, i32* %4
%10 = load i32, i32* %4
%11 = sext i32 %10 to i64
%12 = mul i64 %11, 1
%13 = call i8* @malloc(i64 %12)
store i8* %13, i8** %9
%14 = load i32, i32* %4
%15 = sub nsw i32 %14, 1
store i32 %15, i32* %5
br label %16
16: ; preds = %80, %2
%17 = load i32, i32* %5
%18 = icmp sgt i32 %17, 0
br i1 %18, label %19, label %83
19: ; preds = %16
%20 = load i8*, i8** %3
%21 = load i32, i32* %5
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = load i8*, i8** %3
%27 = load i32, i32* %5
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %26, i64 %28
%30 = getelementptr inbounds i8, i8* %29, i64 -1
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = icmp sgt i32 %25, %32
br i1 %33, label %34, label %57
34: ; preds = %19
%35 = load i32, i32* %5
store i32 %35, i32* %6
%36 = load i8*, i8** %3
%37 = load i32, i32* %5
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
store i8 %40, i8* %8
%41 = load i8*, i8** %3
%42 = load i32, i32* %5
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = getelementptr inbounds i8, i8* %44, i64 -1
%46 = load i8, i8* %45
%47 = load i8*, i8** %3
%48 = load i32, i32* %5
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
store i8 %46, i8* %50
%51 = load i8, i8* %8
%52 = load i8*, i8** %3
%53 = load i32, i32* %5
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = getelementptr inbounds i8, i8* %55, i64 1
store i8 %51, i8* %56
br label %83
57: ; preds = %19
%58 = load i8*, i8** %3
%59 = load i32, i32* %5
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %58, i64 %60
%62 = load i8, i8* %61
store i8 %62, i8* %8
%63 = load i8*, i8** %3
%64 = load i32, i32* %5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8, i8* %63, i64 %65
%67 = getelementptr inbounds i8, i8* %66, i64 -1
%68 = load i8, i8* %67
%69 = load i8*, i8** %3
%70 = load i32, i32* %5
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
store i8 %68, i8* %72
%73 = load i8, i8* %8
%74 = load i8*, i8** %3
%75 = load i32, i32* %5
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
%78 = getelementptr inbounds i8, i8* %77, i64 -1
store i8 %73, i8* %78
br label %79
79: ; preds = %57
br label %80
80: ; preds = %79
%81 = load i32, i32* %5
%82 = add nsw i32 %81, -1
store i32 %82, i32* %5
br label %16
83: ; preds = %34, %16
%84 = load i32, i32* %5
%85 = icmp eq i32 %84, 0
br i1 %85, label %86, label %88
86: ; preds = %83
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
br label %152
88: ; preds = %83
store i32 0, i32* %7
br label %89
89: ; preds = %110, %88
%90 = load i32, i32* %7
%91 = load i32, i32* %4
%92 = load i32, i32* %5
%93 = sub nsw i32 %91, %92
%94 = sub nsw i32 %93, 1
%95 = icmp slt i32 %90, %94
br i1 %95, label %96, label %113
96: ; preds = %89
%97 = load i8*, i8** %3
%98 = load i32, i32* %5
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
%101 = load i32, i32* %7
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %100, i64 %102
%104 = getelementptr inbounds i8, i8* %103, i64 1
%105 = load i8, i8* %104
%106 = load i8*, i8** %9
%107 = load i32, i32* %7
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %106, i64 %108
store i8 %105, i8* %109
br label %110
110: ; preds = %96
%111 = load i32, i32* %7
%112 = add nsw i32 %111, 1
store i32 %112, i32* %7
br label %89
113: ; preds = %89
store i32 0, i32* %7
br label %114
114: ; preds = %145, %113
%115 = load i32, i32* %7
%116 = load i32, i32* %4
%117 = load i32, i32* %5
%118 = sub nsw i32 %116, %117
%119 = sub nsw i32 %118, 1
%120 = icmp slt i32 %115, %119
br i1 %120, label %121, label %148
121: ; preds = %114
%122 = load i8*, i8** %9
%123 = load i32, i32* %4
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i8, i8* %122, i64 %124
%126 = load i32, i32* %5
%127 = sext i32 %126 to i64
%128 = sub i64 0, %127
%129 = getelementptr inbounds i8, i8* %125, i64 %128
%130 = getelementptr inbounds i8, i8* %129, i64 -1
%131 = getelementptr inbounds i8, i8* %130, i64 -1
%132 = load i32, i32* %7
%133 = sext i32 %132 to i64
%134 = sub i64 0, %133
%135 = getelementptr inbounds i8, i8* %131, i64 %134
%136 = load i8, i8* %135
%137 = load i8*, i8** %3
%138 = load i32, i32* %5
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8, i8* %137, i64 %139
%141 = getelementptr inbounds i8, i8* %140, i64 1
%142 = load i32, i32* %7
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i8, i8* %141, i64 %143
store i8 %136, i8* %144
br label %145
145: ; preds = %121
%146 = load i32, i32* %7
%147 = add nsw i32 %146, 1
store i32 %147, i32* %7
br label %114
148: ; preds = %114
br label %149
149: ; preds = %148
%150 = load i8*, i8** %3
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %150)
br label %152
152: ; preds = %149, %86
ret void
}

LLVM IR (-O2):
@.str = [10 x i8] c"No Answer\00"
@.str.1 = [3 x i8] c"%s\00"
define void @lexo(i8* %0, i32 %1) {
%3 = sext i32 %1 to i64
%4 = tail call i8* @malloc(i64 %3)
%5 = add i32 %1, -1
%6 = icmp sgt i32 %1, 1
br i1 %6, label %7, label %36
7: ; preds = %2
%8 = zext i32 %5 to i64
%9 = getelementptr inbounds i8, i8* %0, i64 %8
%10 = load i8, i8* %9
%11 = getelementptr inbounds i8, i8* %9, i64 -1
%12 = load i8, i8* %11
%13 = icmp sgt i8 %10, %12
br i1 %13, label %21, label %28
14: ; preds = %28
%15 = zext i32 %34 to i64
%16 = getelementptr inbounds i8, i8* %0, i64 %15
%17 = load i8, i8* %16
%18 = getelementptr inbounds i8, i8* %16, i64 -1
%19 = load i8, i8* %18
%20 = icmp sgt i8 %17, %19
br i1 %20, label %21, label %28
21: ; preds = %14, %7
%22 = phi i32 [ %5, %7 ], [ %34, %14 ]
%23 = phi i32 [ %1, %7 ], [ %33, %14 ]
%24 = phi i8* [ %9, %7 ], [ %16, %14 ]
%25 = phi i8 [ %10, %7 ], [ %17, %14 ]
%26 = phi i8 [ %12, %7 ], [ %19, %14 ]
store i8 %26, i8* %24
%27 = getelementptr inbounds i8, i8* %24, i64 1
store i8 %25, i8* %27
br label %38
28: ; preds = %7, %14
%29 = phi i8 [ %19, %14 ], [ %12, %7 ]
%30 = phi i8* [ %18, %14 ], [ %11, %7 ]
%31 = phi i8 [ %17, %14 ], [ %10, %7 ]
%32 = phi i8* [ %16, %14 ], [ %9, %7 ]
%33 = phi i32 [ %34, %14 ], [ %5, %7 ]
store i8 %29, i8* %32
store i8 %31, i8* %30
%34 = add nsw i32 %33, -1
%35 = icmp sgt i32 %33, 1
br i1 %35, label %14, label %43
36: ; preds = %2
%37 = icmp eq i32 %5, 0
br i1 %37, label %43, label %38
38: ; preds = %21, %36
%39 = phi i32 [ %22, %21 ], [ %5, %36 ]
%40 = phi i32 [ %23, %21 ], [ %1, %36 ]
%41 = sub i32 %1, %40
%42 = icmp sgt i32 %41, 0
br i1 %42, label %45, label %117
43: ; preds = %28, %36
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
br label %119
45: ; preds = %38
%46 = sext i32 %39 to i64
%47 = add nsw i64 %46, 1
%48 = getelementptr i8, i8* %0, i64 %47
%49 = sub i32 %5, %40
%50 = zext i32 %49 to i64
%51 = add nuw nsw i64 %50, 1
%52 = getelementptr inbounds i8, i8* %4, i64 %3
%53 = sext i32 %39 to i64
%54 = sub nsw i64 0, %53
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = getelementptr inbounds i8, i8* %55, i64 -1
%57 = getelementptr inbounds i8, i8* %56, i64 -1
%58 = getelementptr inbounds i8, i8* %0, i64 %53
%59 = getelementptr inbounds i8, i8* %58, i64 1
%60 = zext i32 %41 to i64
%61 = icmp ult i32 %41, 8
br i1 %61, label %107, label %62
62: ; preds = %45
%63 = icmp ult i32 %41, 32
br i1 %63, label %90, label %64
64: ; preds = %62
%65 = and i64 %60, 4294967264
br label %66
66: ; preds = %66, %64
%67 = phi i64 [ 0, %64 ], [ %83, %66 ]
%68 = sub nsw i64 0, %67
%69 = getelementptr inbounds i8, i8* %57, i64 %68
%70 = getelementptr inbounds i8, i8* %69, i64 -15
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = shufflevector <16 x i8> %72, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%74 = getelementptr inbounds i8, i8* %69, i64 -16
%75 = getelementptr inbounds i8, i8* %74, i64 -15
%76 = bitcast i8* %75 to <16 x i8>*
%77 = load <16 x i8>, <16 x i8>* %76
%78 = shufflevector <16 x i8> %77, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%79 = getelementptr inbounds i8, i8* %59, i64 %67
%80 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %80
%81 = getelementptr inbounds i8, i8* %79, i64 16
%82 = bitcast i8* %81 to <16 x i8>*
store <16 x i8> %78, <16 x i8>* %82
%83 = add nuw i64 %67, 32
%84 = icmp eq i64 %83, %65
br i1 %84, label %85, label %66
85: ; preds = %66
%86 = icmp eq i64 %65, %60
br i1 %86, label %117, label %87
87: ; preds = %85
%88 = and i64 %60, 24
%89 = icmp eq i64 %88, 0
br i1 %89, label %107, label %90
90: ; preds = %62, %87
%91 = phi i64 [ %65, %87 ], [ 0, %62 ]
%92 = and i64 %60, 4294967288
%93 = getelementptr inbounds i8, i8* %57, i64 -7
br label %94
94: ; preds = %94, %90
%95 = phi i64 [ %91, %90 ], [ %103, %94 ]
%96 = sub nsw i64 0, %95
%97 = getelementptr inbounds i8, i8* %93, i64 %96
%98 = bitcast i8* %97 to <8 x i8>*
%99 = load <8 x i8>, <8 x i8>* %98
%100 = shufflevector <8 x i8> %99, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%101 = getelementptr inbounds i8, i8* %59, i64 %95
%102 = bitcast i8* %101 to <8 x i8>*
store <8 x i8> %100, <8 x i8>* %102
%103 = add nuw i64 %95, 8
%104 = icmp eq i64 %103, %92
br i1 %104, label %105, label %94
105: ; preds = %94
%106 = icmp eq i64 %92, %60
br i1 %106, label %117, label %107
107: ; preds = %45, %87, %105
%108 = phi i64 [ 0, %45 ], [ %65, %87 ], [ %92, %105 ]
br label %109
109: ; preds = %107, %109
%110 = phi i64 [ %115, %109 ], [ %108, %107 ]
%111 = sub nsw i64 0, %110
%112 = getelementptr inbounds i8, i8* %57, i64 %111
%113 = load i8, i8* %112
%114 = getelementptr inbounds i8, i8* %59, i64 %110
store i8 %113, i8* %114
%115 = add nuw nsw i64 %110, 1
%116 = icmp eq i64 %115, %60
br i1 %116, label %117, label %109
117: ; preds = %109, %85, %105, %38
%118 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %0)
br label %119
119: ; preds = %117, %43
ret void
}