#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 */
typedef int int32_t;
typedef int /*<<< orphan*/ ac_buf;

/* Variables and functions */
int /*<<< orphan*/ memcpy(char *, char *, int const);
int /*<<< orphan*/ memset(char *, char, int);
void dumpio_ednchg(void *avp_pointer, const int32_t ai_size,
                   const int32_t ai_num) {
  int ai_csize, ai_cnum;
  char ac_buf[16];
  char *acp_tmp;
  char *acp_local;
  memset(ac_buf, '\0', sizeof(ac_buf));
  acp_tmp = avp_pointer;
  acp_local = avp_pointer;
  for (ai_cnum = 0; ai_cnum < ai_num; ai_cnum++) {
    memcpy(ac_buf, acp_local, ai_size);
    for (ai_csize = 0; ai_csize < ai_size; ai_csize++) {
      *acp_local = ac_buf[ai_size - ai_csize - 1];
      acp_local++;
    }
    acp_tmp += ai_size;
  }
}


x86 assembly (clang, -O0):
<dumpio_ednchg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
lea    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11d6 <dumpio_ednchg+0xb6>
lea    -0x30(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b7 <dumpio_ednchg+0x97>
mov    -0xc(%rbp),%eax
sub    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x30(%rbp,%rax,1),%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    117c <dumpio_ednchg+0x5c>
mov    -0xc(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1159 <dumpio_ednchg+0x39>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dumpio_ednchg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %edx,%ebp
mov    %esi,%r12d
mov    %rdi,%rbx
lea    0x10(%rsp),%rdi
xor    %r15d,%r15d
xor    %esi,%esi
mov    $0x10,%edx
call   1030 <memset@plt>
mov    %ebp,0x34(%rsp)
test   %ebp,%ebp
jle    13c7 <dumpio_ednchg+0x2a7>
mov    %r12d,%r14d
lea    -0x1(%r14),%rax
lea    -0x1(%r12),%ecx
mov    %ecx,0xc(%rsp)
movslq %ecx,%rcx
lea    0x1(%rcx),%rdx
sub    %r14,%rdx
add    %rsp,%rdx
add    $0x10,%rdx
mov    %rdx,0x38(%rsp)
lea    (%rsp,%rcx,1),%rdx
add    $0x11,%rdx
mov    %rdx,0x48(%rsp)
mov    %ecx,%edx
sub    %eax,%edx
cmp    %ecx,%edx
setg   %cl
shr    $0x20,%rax
setne  %al
or     %cl,%al
mov    %al,0xb(%rsp)
mov    %r14d,%r13d
and    $0xffffffe0,%r13d
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0x50(%rsp)
lea    -0x4(%r12),%eax
mov    %eax,0x30(%rsp)
lea    -0x3(%r12),%eax
mov    %eax,0x2c(%rsp)
lea    -0x2(%r12),%eax
mov    %eax,0x28(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x40(%rsp)
jmp    11f5 <dumpio_ednchg+0xd5>
nopl   0x0(%rax)
mov    %rbx,%rax
add    $0x1,%r15d
mov    %rax,%rbx
cmp    0x34(%rsp),%r15d
je     13c7 <dumpio_ednchg+0x2a7>
lea    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    %r12d,%edx
call   1040 <memcpy@plt>
test   %r12d,%r12d
jle    11e0 <dumpio_ednchg+0xc0>
cmp    $0x20,%r12d
setb   %al
or     0xb(%rsp),%al
jne    1231 <dumpio_ednchg+0x111>
cmp    0x48(%rsp),%rbx
jae    1313 <dumpio_ednchg+0x1f3>
lea    (%rbx,%r14,1),%rax
cmp    %rax,0x38(%rsp)
jae    1313 <dumpio_ednchg+0x1f3>
xor    %ebp,%ebp
mov    %rbx,%rax
mov    %rbp,%rdx
not    %rdx
add    %r14,%rdx
mov    0x50(%rsp),%rdi
test   %rdi,%rdi
je     127b <dumpio_ednchg+0x15b>
mov    0xc(%rsp),%ecx
mov    %ecx,%esi
sub    %ebp,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %esi,%rsi
movzbl 0x10(%rsp,%rsi,1),%ebx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0x1,%rbp
add    $0xffffffff,%esi
add    $0xffffffffffffffff,%rdi
jne    1260 <dumpio_ednchg+0x140>
cmp    $0x3,%rdx
jb     11e3 <dumpio_ednchg+0xc3>
mov    %ebp,%edx
mov    0x30(%rsp),%ecx
mov    %ecx,%r8d
sub    %ebp,%r8d
mov    0x2c(%rsp),%ecx
mov    %ecx,%r9d
sub    %ebp,%r9d
mov    0x28(%rsp),%ecx
mov    %ecx,%r10d
sub    %ebp,%r10d
add    0x40(%rsp),%rbp
mov    0xc(%rsp),%ecx
mov    %ecx,%edi
sub    %edx,%edi
xor    %edx,%edx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
lea    (%rdi,%rbx,1),%esi
movslq %esi,%rsi
movzbl 0x10(%rsp,%rsi,1),%ecx
mov    %cl,(%rax,%rdx,1)
lea    (%r10,%rbx,1),%ecx
movslq %ecx,%rcx
movzbl 0x10(%rsp,%rcx,1),%ecx
mov    %cl,0x1(%rax,%rdx,1)
lea    (%r9,%rbx,1),%ecx
movslq %ecx,%rcx
movzbl 0x10(%rsp,%rcx,1),%ecx
mov    %cl,0x2(%rax,%rdx,1)
lea    (%r8,%rbx,1),%ecx
movslq %ecx,%rcx
movzbl 0x10(%rsp,%rcx,1),%ecx
mov    %cl,0x3(%rax,%rdx,1)
add    $0xfffffffffffffffc,%rbx
add    $0x4,%rdx
cmp    %rbx,%rbp
jne    12c0 <dumpio_ednchg+0x1a0>
sub    %rbx,%rax
jmp    11e3 <dumpio_ednchg+0xc3>
lea    (%rbx,%r13,1),%rax
mov    0xc(%rsp),%ecx
xor    %edx,%edx
pxor   %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movdqu -0xf(%rsp,%rcx,1),%xmm0
movdqu 0x1(%rsp,%rcx,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm1,(%rbx,%rdx,1)
movdqu %xmm0,0x10(%rbx,%rdx,1)
add    $0x20,%rdx
add    $0xffffffe0,%ecx
cmp    %rdx,%r13
jne    1330 <dumpio_ednchg+0x210>
mov    %r13,%rbp
cmp    %r14,%r13
je     11e3 <dumpio_ednchg+0xc3>
jmp    1236 <dumpio_ednchg+0x116>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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