#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 */
char *malloc(int);
int strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, int);
char *sc(char str[]) {
  int i, j, k;
  int len;
  int count;
  char *old;
  len = strlen(str);
  old = malloc(sizeof(len + 1));
  strncpy(old, str, len);
  if (len < 1)
    return str;
  for (i = 0; i < len; i++, i++) {
    for (count = 1, j = i + 1; j < len + 1; j++)
      if (str[i] == str[j])
        count++;
      else {
        if (count == 1) {
          for (k = len - 1; k >= j; k--)
            str[k + 1] = str[k];
          len++;
        } else {
          for (k = i + 2; k < len - count + 2; k++)
            str[k] = str[k + count - 2];
          len = len - count + 2;
          str[len] = '\0';
        }
        str[i + 1] = '0' + count;
        break;
      }
  }
  if (strlen(str) > strlen(old))
    return old;
  else
    return str;
}


x86 assembly (clang, -O0):
<sc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x20(%rbp)
mov    $0x4,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1030 <strncpy@plt>
cmpl   $0x1,-0x20(%rbp)
jge    117d <sc+0x4d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1319 <sc+0x1e9>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12e2 <sc+0x1b2>
movl   $0x1,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12c6 <sc+0x196>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    11df <sc+0xaf>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b3 <sc+0x183>
cmpl   $0x1,-0x24(%rbp)
jne    1235 <sc+0x105>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jl     1227 <sc+0xf7>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11f2 <sc+0xc2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1296 <sc+0x166>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    127e <sc+0x14e>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    123e <sc+0x10e>
mov    -0x20(%rbp),%eax
sub    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    12c6 <sc+0x196>
jmp    12b8 <sc+0x188>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11a0 <sc+0x70>
jmp    12cb <sc+0x19b>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1184 <sc+0x54>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
cmp    %ecx,%eax
jle    1311 <sc+0x1e1>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1319 <sc+0x1e9>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdi,%rbp
call   1040 <strlen@plt>
mov    %eax,%ebx
mov    $0x4,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
mov    %rbp,%rsi
mov    %ebx,%edx
call   1030 <strncpy@plt>
test   %ebx,%ebx
jle    17da <sc+0x6aa>
mov    %rbx,0x58(%rsp)
mov    %r14,0x90(%rsp)
movabs $0x100000000,%r9
lea    0x1(%rbp),%rax
mov    %rax,0x60(%rsp)
lea    0x32(%rbp),%r8
mov    %rbp,0x18(%rsp)
lea    0x2(%rbp),%rdx
lea    -0x1(%r9),%r11
mov    $0x2,%r14d
mov    $0xffffffffffffffff,%r13
mov    $0x3,%ebx
mov    $0x21,%edi
mov    $0xfffffffffffffffe,%rsi
mov    $0x1,%ecx
xor    %ebp,%ebp
xor    %eax,%eax
jmp    1229 <sc+0xf9>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rax
movabs $0x200000000,%r12
mov    0x80(%rsp),%r10
add    $0x2,%r10
add    $0x2,%r14
add    $0x1,%rbp
add    $0xfffffffffffffffe,%r13
add    %r12,%r9
add    $0xfffffffffffffffe,%r11
add    $0x2,%rax
mov    %rax,0x60(%rsp)
add    $0x2,%rbx
add    $0x2,%edi
add    $0x2,%r8
add    $0xfffffffffffffffe,%rsi
add    $0x2,%ecx
add    $0x2,%rdx
cmp    %r15,%r10
mov    %r10,%rax
jge    17b3 <sc+0x683>
mov    %rax,%r10
or     $0x1,%r10
mov    0x58(%rsp),%r12
movslq %r12d,%r15
cmp    %r15,%r10
mov    %rax,0x80(%rsp)
jg     11d0 <sc+0xa0>
mov    %r10,0x40(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x30(%rsp)
mov    %rdx,0x28(%rsp)
mov    %r8,0x68(%rsp)
lea    0x3(%rax),%rdx
mov    %rdx,0xb0(%rsp)
mov    %rbp,0x38(%rsp)
mov    %rbp,%rdx
add    %rbp,%rdx
mov    $0xfffffffffffffffd,%rsi
sub    %rdx,%rsi
mov    %rsi,0xa8(%rsp)
xor    $0xfffffffffffffffe,%rdx
mov    %r14,0x50(%rsp)
mov    0x18(%rsp),%rsi
lea    (%rsi,%r14,1),%rbp
mov    %rbp,0xa0(%rsp)
mov    %rdx,%r14
add    %rsi,%rdx
mov    %rdx,0x98(%rsp)
mov    (%rsi,%rax,1),%dl
lea    0x1(%r12),%ebx
lea    0x0(%r13,%rbx,1),%rbp
mov    %r13,0x48(%rsp)
lea    (%r12,%r13,1),%esi
mov    $0xffffffff,%r11d
mov    %ecx,0x8(%rsp)
mov    %ecx,%r10d
mov    %edi,0xc(%rsp)
mov    %edi,%r12d
mov    %ebx,%edi
mov    %r9,0x78(%rsp)
mov    %r9,%r8
xor    %r9d,%r9d
mov    0x60(%rsp),%rax
cmp    (%rax,%r9,1),%dl
jne    1370 <sc+0x240>
add    $0x1,%r9
movabs $0x100000000,%r13
add    %r13,%r8
add    $0xffffffff,%edi
add    $0x1,%r12d
add    $0x1,%r10d
add    $0x1,%r11d
add    $0x3,%sil
cmp    %r9,%rbp
jne    12f0 <sc+0x1c0>
mov    0x68(%rsp),%r8
mov    0x28(%rsp),%rdx
mov    0x30(%rsp),%r11
mov    0x50(%rsp),%r14
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%edi
mov    0x20(%rsp),%rsi
mov    0x8(%rsp),%ecx
mov    0x38(%rsp),%rbp
movabs $0x200000000,%r12
mov    0x78(%rsp),%r9
jmp    11df <sc+0xaf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r9d,%r9d
je     140e <sc+0x2de>
sub    %r9,%rbx
mov    %r9,%rdx
not    %rdx
add    %r15,%rdx
cmp    %rdx,0x80(%rsp)
mov    %rbx,0x70(%rsp)
jge    149b <sc+0x36b>
movslq %ebx,%r15
mov    0xb0(%rsp),%r8
cmp    %r15,%r8
mov    %r15,%rcx
cmovg  %r8,%rcx
add    %r14,%rcx
mov    0x50(%rsp),%rsi
cmp    $0x8,%rcx
jae    153d <sc+0x40d>
add    %esi,%r11d
mov    0x18(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movslq %r11d,%r11
movzbl (%rax,%r11,1),%edx
mov    %dl,(%rax,%rsi,1)
add    $0x1,%rsi
add    $0x1,%r11d
cmp    %r15,%rsi
jl     13d0 <sc+0x2a0>
mov    0x28(%rsp),%rdx
mov    0x30(%rsp),%r11
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%edi
mov    0x20(%rsp),%rsi
mov    0x8(%rsp),%ecx
jmp    14c4 <sc+0x394>
mov    %r9d,%edx
mov    0x30(%rsp),%r11
sub    %r11d,%edx
mov    0x58(%rsp),%rcx
cmp    %edx,%ecx
mov    0x18(%rsp),%rax
mov    %rbx,0x70(%rsp)
jle    14df <sc+0x3af>
sar    $0x20,%r8
mov    0x48(%rsp),%r13
add    %r13d,%ecx
sub    %r9d,%ecx
mov    %r8,%r10
not    %r10
add    %r15,%r10
test   $0x3,%cl
je     15e3 <sc+0x4b3>
movzbl %sil,%edi
and    $0x3,%edi
mov    0x10(%rsp),%rbx
nopl   (%rax)
lea    -0x1(%r15),%rsi
movzbl -0x1(%rax,%r15,1),%edx
mov    %dl,(%rax,%r15,1)
mov    %rsi,%r15
add    $0xffffffffffffffff,%rdi
jne    1460 <sc+0x330>
cmp    $0x3,%r10
jb     1494 <sc+0x364>
nopl   (%rax)
mov    -0x4(%rax,%rsi,1),%edx
mov    %edx,-0x3(%rax,%rsi,1)
lea    -0x4(%rsi),%rdx
mov    %rdx,%rsi
cmp    %r8,%rdx
jg     1480 <sc+0x350>
mov    0x28(%rsp),%rdx
jmp    14ee <sc+0x3be>
movslq %ebx,%r15
mov    0x28(%rsp),%rdx
mov    0x30(%rsp),%r11
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%edi
mov    0x20(%rsp),%rsi
mov    0x8(%rsp),%ecx
mov    0x18(%rsp),%rax
mov    0x38(%rsp),%rbp
movabs $0x200000000,%r12
mov    0x40(%rsp),%r8
movb   $0x0,(%rax,%r15,1)
jmp    150f <sc+0x3df>
mov    0x28(%rsp),%rdx
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%edi
mov    0x20(%rsp),%rsi
mov    0x8(%rsp),%ecx
mov    0x38(%rsp),%rbp
movabs $0x200000000,%r12
mov    0x40(%rsp),%r8
add    $0x31,%r9b
mov    %r9b,(%rax,%r8,1)
mov    0x70(%rsp),%rax
movslq %eax,%r15
mov    %rax,0x58(%rsp)
mov    0x78(%rsp),%r9
mov    0x68(%rsp),%r8
mov    0x50(%rsp),%r14
mov    0x60(%rsp),%rax
jmp    11df <sc+0xaf>
cmp    %r15,%r8
mov    %r15,%rdx
cmovg  %r8,%rdx
mov    %r9d,%ebp
sub    0x30(%rsp),%ebp
movslq %edi,%r13
mov    0x10(%rsp),%rax
cmp    %r13,%rax
mov    %r13,%rsi
cmovg  %rax,%rsi
mov    0x50(%rsp),%rax
lea    (%rsi,%r9,1),%edi
add    $0xfffffffe,%edi
mov    %rax,%rsi
cmp    %ebp,%edi
jl     13bf <sc+0x28f>
add    0xa8(%rsp),%rdx
shr    $0x20,%rdx
mov    %rax,%rsi
jne    13bf <sc+0x28f>
cmp    %r15,%r8
mov    %r15,%rdx
cmovg  %r8,%rdx
mov    %r9d,%esi
sub    0x30(%rsp),%esi
movslq %esi,%rdi
mov    0x98(%rsp),%rax
add    %rdx,%rax
add    %rdi,%rax
cmp    %rax,0xa0(%rsp)
jae    15d1 <sc+0x4a1>
mov    0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rdi
mov    0x50(%rsp),%rsi
cmp    %rdx,%rdi
jb     13bf <sc+0x28f>
cmp    $0x20,%rcx
jae    15fa <sc+0x4ca>
xor    %ecx,%ecx
mov    0x18(%rsp),%r12
jmp    1738 <sc+0x608>
mov    %r15,%rsi
mov    0x10(%rsp),%rbx
cmp    $0x3,%r10
jae    1480 <sc+0x350>
jmp    1494 <sc+0x364>
mov    %rcx,%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x58(%rsp)
lea    -0x20(%rax),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
mov    %rcx,0x88(%rsp)
je     16a2 <sc+0x572>
mov    0x10(%rsp),%rax
cmp    %r13,%rax
mov    %r13,%rdx
cmovg  %rax,%rdx
add    0x20(%rsp),%rdx
and    $0xffffffffffffffe0,%rdx
add    $0xffffffffffffffe0,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
mov    0x18(%rsp),%rax
mov    0x68(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
lea    -0x20(%r12),%ebp
movslq %ebp,%rbp
movups (%rax,%rbp,1),%xmm0
movups 0x10(%rax,%rbp,1),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,1)
movups %xmm1,-0x20(%rcx,%rdi,1)
movslq %r12d,%r12
movups (%rax,%r12,1),%xmm0
movups 0x10(%rax,%r12,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x40,%rdi
add    $0x40,%r12d
add    $0xfffffffffffffffe,%rdx
jne    1660 <sc+0x530>
jmp    16a9 <sc+0x579>
xor    %edi,%edi
mov    0x18(%rsp),%rax
test   $0x1,%sil
mov    %rax,%r12
mov    0x50(%rsp),%rax
je     16df <sc+0x5af>
lea    (%rax,%rdi,1),%rdx
sub    0x30(%rsp),%edi
lea    (%r9,%rdi,1),%esi
movslq %esi,%rsi
mov    %r12,%rcx
movups (%r12,%rsi,1),%xmm0
movups 0x10(%r12,%rsi,1),%xmm1
movups %xmm0,(%r12,%rdx,1)
movups %xmm1,0x10(%r12,%rdx,1)
mov    0x88(%rsp),%rcx
cmp    0x58(%rsp),%rcx
jne    172e <sc+0x5fe>
mov    0x28(%rsp),%rdx
mov    0x30(%rsp),%r11
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%edi
mov    0x20(%rsp),%rsi
mov    0x8(%rsp),%ecx
mov    0x38(%rsp),%rbp
movabs $0x200000000,%r10
mov    0x40(%rsp),%r8
mov    %r12,%rax
mov    %r10,%r12
jmp    14d8 <sc+0x3a8>
test   $0x18,%cl
je     17a6 <sc+0x676>
mov    0x58(%rsp),%rcx
movslq %ebx,%rdx
cmp    %rdx,%r8
cmovg  %r8,%rdx
add    %r14,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
mov    0x50(%rsp),%rax
lea    (%rax,%r8,1),%rsi
add    %ecx,%r10d
mov    0x10(%rsp),%rax
cmp    %r13,%rax
cmovg  %rax,%r13
add    0x20(%rsp),%r13
and    $0xfffffffffffffff8,%r13
sub    %rcx,%r13
add    0x28(%rsp),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    (%r10,%rbp,1),%edi
movslq %edi,%rdi
mov    (%r12,%rdi,1),%rdi
mov    %rdi,(%rcx,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%r13
jne    1780 <sc+0x650>
cmp    %r8,%rdx
jne    13bf <sc+0x28f>
jmp    149e <sc+0x36e>
mov    0x58(%rsp),%rsi
add    %rax,%rsi
jmp    13bf <sc+0x28f>
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
mov    %eax,%r14d
mov    0x90(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
cmp    %eax,%r14d
cmovg  %rbx,%rbp
mov    %rbp,%rax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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