#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__ malloc(int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
unsigned char *deriv1xNB(unsigned char *img, int xs, int ys, int *nc, int *nl) {
  unsigned char *res = (unsigned char *)malloc(xs * ys);
  memcpy(res, img, xs * ys);
  int i, j;
  for (i = 0; i < ys; i++) {
    for (j = xs - 1; j > 0; j--) {
      int index = i * xs + j;
      int left = img[index - 1];
      int right = img[index];
      int d = right - left;
      res[index] = d < -128 ? -128 : d > 127 ? 127 : d;
    }
  }
  *nc = xs;
  *nl = ys;
  return res;
}


x86 assembly (clang, -O0):
<deriv1xNB>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0xc(%rbp),%edi
imul   -0x10(%rbp),%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1228 <deriv1xNB+0x108>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1215 <deriv1xNB+0xf5>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0xffffff80,-0x40(%rbp)
jge    11d4 <deriv1xNB+0xb4>
mov    $0xffffff80,%eax
mov    %eax,-0x44(%rbp)
jmp    11f7 <deriv1xNB+0xd7>
cmpl   $0x7f,-0x40(%rbp)
jle    11eb <deriv1xNB+0xcb>
mov    $0x7f,%eax
mov    %eax,-0x48(%rbp)
jmp    11f1 <deriv1xNB+0xd1>
mov    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    117a <deriv1xNB+0x5a>
jmp    121a <deriv1xNB+0xfa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1165 <deriv1xNB+0x45>
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<deriv1xNB>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8,0x48(%rsp)
mov    %rcx,0x40(%rsp)
mov    %edx,%ebx
mov    %esi,%r14d
mov    %rdi,%rbp
mov    %edx,%r12d
imul   %esi,%r12d
mov    %r12d,%edi
call   1040 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %rax,%rdi
mov    %rbp,0x20(%rsp)
mov    %rbp,%rsi
mov    %r12d,%edx
mov    %r14d,%r12d
call   1030 <memcpy@plt>
mov    %ebx,0x10(%rsp)
test   %ebx,%ebx
jle    1500 <deriv1xNB+0x3e0>
movslq %r12d,%rbx
mov    0x10(%rsp),%eax
mov    %rax,0x60(%rsp)
lea    -0x1(%rbx),%r10
mov    %r10,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rbx,%rax
sub    %rdx,%rax
mov    %rax,0x30(%rsp)
mov    %r10,%rax
mov    %r10,0x8(%rsp)
and    $0xfffffffffffffffc,%r10
mov    %rbx,%rax
sub    %r10,%rax
mov    %rax,0x50(%rsp)
mov    0x18(%rsp),%r15
lea    (%r15,%rbx,1),%rdi
add    $0xfffffffffffffff0,%rdi
mov    0x20(%rsp),%r13
lea    (%rbx,%r13,1),%rsi
add    $0xfffffffffffffff0,%rsi
mov    %rdx,0x28(%rsp)
neg    %rdx
mov    %rdx,0x38(%rsp)
lea    (%rbx,%r15,1),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %r10,0x58(%rsp)
neg    %r10
lea    (%rbx,%r13,1),%r9
add    $0xfffffffffffffffb,%r9
xor    %r14d,%r14d
mov    $0x7f,%r8d
movdqa 0xe00(%rip),%xmm9
movdqa 0xe07(%rip),%xmm11
movdqa 0xe0e(%rip),%xmm10
movdqa 0xe15(%rip),%xmm8
pxor   %xmm4,%xmm4
mov    $0x80,%r11d
mov    %r12d,0x14(%rsp)
jmp    1251 <deriv1xNB+0x131>
nopl   0x0(%rax)
add    $0x1,%r14
add    %rbx,%rdi
add    %rbx,%rsi
add    %rbx,%rdx
add    %rbx,%r9
add    %rbx,%r13
add    %rbx,%r15
cmp    0x60(%rsp),%r14
je     1500 <deriv1xNB+0x3e0>
cmp    $0x2,%r12d
jl     1230 <deriv1xNB+0x110>
mov    %rbx,%rax
cmpq   $0x4,0x8(%rsp)
jb     14c0 <deriv1xNB+0x3a0>
mov    %r14,%rcx
imul   %rbx,%rcx
lea    (%rcx,%rbx,1),%rbp
mov    0x20(%rsp),%rax
lea    (%rax,%rbp,1),%r12
mov    0x18(%rsp),%rax
add    %rcx,%rax
add    $0x1,%rax
cmp    %r12,%rax
mov    0x14(%rsp),%r12d
jae    12a6 <deriv1xNB+0x186>
add    0x18(%rsp),%rbp
add    0x20(%rsp),%rcx
mov    %rbx,%rax
cmp    %rbp,%rcx
jb     14c0 <deriv1xNB+0x3a0>
cmpq   $0x10,0x8(%rsp)
jae    12b5 <deriv1xNB+0x195>
xor    %ecx,%ecx
jmp    13f8 <deriv1xNB+0x2d8>
xor    %r12d,%r12d
mov    0x38(%rsp),%rax
nopl   (%rax)
movdqu -0x1(%rsi,%r12,1),%xmm5
movdqu (%rsi,%r12,1),%xmm2
movdqa %xmm5,%xmm6
punpcklbw %xmm4,%xmm6
pshufd $0x4e,%xmm6,%xmm6
pshuflw $0x1b,%xmm6,%xmm6
pshufhw $0x1b,%xmm6,%xmm6
punpckhbw %xmm4,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
packuswb %xmm6,%xmm5
movdqa %xmm5,%xmm6
punpckhbw %xmm4,%xmm6
movdqa %xmm6,%xmm0
punpcklwd %xmm4,%xmm0
punpckhwd %xmm4,%xmm6
punpcklbw %xmm4,%xmm5
movdqa %xmm5,%xmm7
punpcklwd %xmm4,%xmm7
punpckhwd %xmm4,%xmm5
movdqa %xmm2,%xmm3
punpcklbw %xmm4,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm4,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm2,%xmm3
punpckhbw %xmm4,%xmm3
movdqa %xmm3,%xmm1
punpcklwd %xmm4,%xmm1
psubd  %xmm0,%xmm1
punpckhwd %xmm4,%xmm3
psubd  %xmm6,%xmm3
packssdw %xmm3,%xmm1
punpcklbw %xmm4,%xmm2
movdqa %xmm2,%xmm0
punpcklwd %xmm4,%xmm0
psubd  %xmm7,%xmm0
punpckhwd %xmm4,%xmm2
psubd  %xmm5,%xmm2
packssdw %xmm2,%xmm0
packsswb %xmm1,%xmm0
movdqa %xmm0,%xmm1
punpcklbw %xmm4,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm4,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rdi,%r12,1)
add    $0xfffffffffffffff0,%r12
cmp    %r12,%rax
jne    12c0 <deriv1xNB+0x1a0>
mov    0x28(%rsp),%rax
cmp    %rax,0x8(%rsp)
mov    0x14(%rsp),%r12d
je     1230 <deriv1xNB+0x110>
mov    0x28(%rsp),%rcx
mov    0x30(%rsp),%rax
testb  $0xc,0x8(%rsp)
je     14c0 <deriv1xNB+0x3a0>
neg    %rcx
nopl   0x0(%rax,%rax,1)
movd   (%r9,%rcx,1),%xmm0
punpcklbw %xmm0,%xmm0
pshufd $0xc4,%xmm0,%xmm0
pshuflw $0xe7,%xmm0,%xmm0
pshufhw $0xc5,%xmm0,%xmm0
pand   %xmm9,%xmm0
movd   0x1(%r9,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pand   %xmm9,%xmm1
psubd  %xmm0,%xmm1
movdqa %xmm11,%xmm0
pcmpgtd %xmm1,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm11,%xmm0
por    %xmm1,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm10,%xmm1
pand   %xmm1,%xmm0
pandn  %xmm10,%xmm1
por    %xmm0,%xmm1
pand   %xmm8,%xmm1
pshuflw $0xe8,%xmm1,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   %xmm0,(%rdx,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%r10
jne    1400 <deriv1xNB+0x2e0>
mov    0x50(%rsp),%rax
mov    0x58(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
je     1230 <deriv1xNB+0x110>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x3(%r13,%rax,1),%ecx
movzbl -0x2(%r13,%rax,1),%ebp
sub    %ecx,%ebp
cmp    $0x7f,%ebp
cmovge %r8d,%ebp
cmp    $0xffffff81,%ebp
cmovl  %r11d,%ebp
mov    %bpl,-0x2(%r15,%rax,1)
add    $0xffffffffffffffff,%rax
cmp    $0x2,%rax
jg     14d0 <deriv1xNB+0x3b0>
jmp    1230 <deriv1xNB+0x110>
mov    0x40(%rsp),%rax
mov    %r12d,(%rax)
mov    0x48(%rsp),%rax
mov    0x10(%rsp),%ecx
mov    %ecx,(%rax)
mov    0x18(%rsp),%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @deriv1xNB(i8* %0, i32 %1, i32 %2, i32* %3, i32* %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i8* %0, i8** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32* %3, i32** %9
store i32* %4, i32** %10
%18 = load i32, i32* %7
%19 = load i32, i32* %8
%20 = mul nsw i32 %18, %19
%21 = call i64 @malloc(i32 %20)
%22 = inttoptr i64 %21 to i8*
store i8* %22, i8** %11
%23 = load i8*, i8** %11
%24 = load i8*, i8** %6
%25 = load i32, i32* %7
%26 = load i32, i32* %8
%27 = mul nsw i32 %25, %26
%28 = call i32 @memcpy(i8* %23, i8* %24, i32 %27)
store i32 0, i32* %12
br label %29
29: ; preds = %83, %5
%30 = load i32, i32* %12
%31 = load i32, i32* %8
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %86
33: ; preds = %29
%34 = load i32, i32* %7
%35 = sub nsw i32 %34, 1
store i32 %35, i32* %13
br label %36
36: ; preds = %79, %33
%37 = load i32, i32* %13
%38 = icmp sgt i32 %37, 0
br i1 %38, label %39, label %82
39: ; preds = %36
%40 = load i32, i32* %12
%41 = load i32, i32* %7
%42 = mul nsw i32 %40, %41
%43 = load i32, i32* %13
%44 = add nsw i32 %42, %43
store i32 %44, i32* %14
%45 = load i8*, i8** %6
%46 = load i32, i32* %14
%47 = sub nsw i32 %46, 1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %45, i64 %48
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
store i32 %51, i32* %15
%52 = load i8*, i8** %6
%53 = load i32, i32* %14
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = load i8, i8* %55
%57 = zext i8 %56 to i32
store i32 %57, i32* %16
%58 = load i32, i32* %16
%59 = load i32, i32* %15
%60 = sub nsw i32 %58, %59
store i32 %60, i32* %17
%61 = load i32, i32* %17
%62 = icmp slt i32 %61, -128
br i1 %62, label %63, label %64
63: ; preds = %39
br label %72
64: ; preds = %39
%65 = load i32, i32* %17
%66 = icmp sgt i32 %65, 127
br i1 %66, label %67, label %68
67: ; preds = %64
br label %70
68: ; preds = %64
%69 = load i32, i32* %17
br label %70
70: ; preds = %68, %67
%71 = phi i32 [ 127, %67 ], [ %69, %68 ]
br label %72
72: ; preds = %70, %63
%73 = phi i32 [ -128, %63 ], [ %71, %70 ]
%74 = trunc i32 %73 to i8
%75 = load i8*, i8** %11
%76 = load i32, i32* %14
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %75, i64 %77
store i8 %74, i8* %78
br label %79
79: ; preds = %72
%80 = load i32, i32* %13
%81 = add nsw i32 %80, -1
store i32 %81, i32* %13
br label %36
82: ; preds = %36
br label %83
83: ; preds = %82
%84 = load i32, i32* %12
%85 = add nsw i32 %84, 1
store i32 %85, i32* %12
br label %29
86: ; preds = %29
%87 = load i32, i32* %7
%88 = load i32*, i32** %9
store i32 %87, i32* %88
%89 = load i32, i32* %8
%90 = load i32*, i32** %10
store i32 %89, i32* %90
%91 = load i8*, i8** %11
ret i8* %91
}

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