#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__ readAck(int);
int write(int, unsigned char *, int);
int sendData(int fd, void *ptr, unsigned len) {
  unsigned char x;
  unsigned char check;
  unsigned char *data = ptr;
  unsigned n;
  if ((len < 1) || (len > 256))
    return -1;
  check = x = (len - 1);
  for (n = 0; n < len; n++) {
    check ^= data[n];
  }
  if (write(fd, &x, 1) != 1)
    return -1;
  if (write(fd, data, len) != len)
    return -1;
  if (write(fd, &check, 1) != 1)
    return -1;
  if (readAck(fd))
    return -1;
  return 0;
}


x86 assembly (clang, -O0):
<sendData>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpl   $0x1,-0x14(%rbp)
jb     1151 <sendData+0x31>
cmpl   $0x100,-0x14(%rbp)
jbe    115d <sendData+0x3d>
movl   $0xffffffff,-0x4(%rbp)
jmp    1233 <sendData+0x113>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %al,-0x15(%rbp)
mov    %al,-0x16(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    119e <sendData+0x7e>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0x16(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x16(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1170 <sendData+0x50>
mov    -0x8(%rbp),%edi
lea    -0x15(%rbp),%rsi
mov    $0x1,%edx
call   1030 <write@plt>
cmp    $0x1,%eax
je     11c4 <sendData+0xa4>
movl   $0xffffffff,-0x4(%rbp)
jmp    1233 <sendData+0x113>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <write@plt>
cmp    -0x14(%rbp),%eax
je     11e8 <sendData+0xc8>
movl   $0xffffffff,-0x4(%rbp)
jmp    1233 <sendData+0x113>
mov    -0x8(%rbp),%edi
lea    -0x16(%rbp),%rsi
mov    $0x1,%edx
call   1030 <write@plt>
cmp    $0x1,%eax
je     120e <sendData+0xee>
movl   $0xffffffff,-0x4(%rbp)
jmp    1233 <sendData+0x113>
mov    -0x8(%rbp),%edi
call   1040 <readAck@plt>
cmp    $0x0,%rax
je     122c <sendData+0x10c>
movl   $0xffffffff,-0x4(%rbp)
jmp    1233 <sendData+0x113>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sendData>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %edx,%ebp
lea    -0x101(%rbp),%eax
mov    $0xffffffff,%r15d
cmp    $0xffffff00,%eax
jb     133d <sendData+0x21d>
mov    %rsi,%rbx
mov    %edi,%r14d
lea    -0x1(%rbp),%edx
mov    %dl,0x7(%rsp)
mov    %ebp,%eax
cmp    $0x8,%ebp
jae    115b <sendData+0x3b>
xor    %ecx,%ecx
jmp    12e0 <sendData+0x1c0>
cmp    $0x20,%ebp
jae    1167 <sendData+0x47>
xor    %ecx,%ecx
jmp    128f <sendData+0x16f>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
movzbl %dl,%edx
movd   %edx,%xmm1
movdqu (%rbx),%xmm0
pxor   %xmm1,%xmm0
movdqu 0x10(%rbx),%xmm1
cmp    $0x20,%rcx
je     1252 <sendData+0x132>
movdqu 0x20(%rbx),%xmm2
movdqu 0x30(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
cmp    $0x40,%ecx
je     1252 <sendData+0x132>
movdqu 0x40(%rbx),%xmm2
movdqu 0x50(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
cmp    $0x60,%ecx
je     1252 <sendData+0x132>
movdqu 0x60(%rbx),%xmm2
movdqu 0x70(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
cmp    $0x80,%ecx
je     1252 <sendData+0x132>
movdqu 0x80(%rbx),%xmm2
movdqu 0x90(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
cmp    $0xa0,%ecx
je     1252 <sendData+0x132>
movdqu 0xa0(%rbx),%xmm2
movdqu 0xb0(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
cmp    $0xc0,%ecx
je     1252 <sendData+0x132>
movdqu 0xc0(%rbx),%xmm2
movdqu 0xd0(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
cmp    $0xe0,%ecx
je     1252 <sendData+0x132>
movdqu 0xe0(%rbx),%xmm2
movdqu 0xf0(%rbx),%xmm3
pxor   %xmm2,%xmm0
pxor   %xmm3,%xmm1
pxor   %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pxor   %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pxor   %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     12ec <sendData+0x1cc>
test   $0x18,%al
je     12e0 <sendData+0x1c0>
mov    %rcx,%rsi
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movzbl %dl,%edx
movd   %edx,%xmm0
xchg   %ax,%ax
movq   (%rbx,%rsi,1),%xmm1
pxor   %xmm1,%xmm0
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    12a0 <sendData+0x180>
pshufd $0x55,%xmm0,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrld  $0x10,%xmm0
pxor   %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrlw  $0x8,%xmm1
pxor   %xmm0,%xmm1
movd   %xmm1,%edx
cmp    %rax,%rcx
je     12ec <sendData+0x1cc>
xchg   %ax,%ax
xor    (%rbx,%rcx,1),%dl
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12e0 <sendData+0x1c0>
mov    %dl,0x6(%rsp)
lea    0x7(%rsp),%rsi
mov    %r14d,%edi
mov    $0x1,%edx
call   1030 <write@plt>
cmp    $0x1,%eax
jne    133d <sendData+0x21d>
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %ebp,%edx
call   1030 <write@plt>
cmp    %ebp,%eax
jne    133d <sendData+0x21d>
lea    0x6(%rsp),%rsi
mov    %r14d,%edi
mov    $0x1,%edx
call   1030 <write@plt>
cmp    $0x1,%eax
jne    133d <sendData+0x21d>
mov    %r14d,%edi
call   1040 <readAck@plt>
neg    %rax
sbb    %r15d,%r15d
mov    %r15d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @sendData(i32 %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8
%9 = alloca i8
%10 = alloca i8*
%11 = alloca i32
store i32 %0, i32* %5
store i8* %1, i8** %6
store i32 %2, i32* %7
%12 = load i8*, i8** %6
store i8* %12, i8** %10
%13 = load i32, i32* %7
%14 = icmp ult i32 %13, 1
br i1 %14, label %18, label %15
15: ; preds = %3
%16 = load i32, i32* %7
%17 = icmp ugt i32 %16, 256
br i1 %17, label %18, label %19
18: ; preds = %15, %3
store i32 -1, i32* %4
br label %65
19: ; preds = %15
%20 = load i32, i32* %7
%21 = sub i32 %20, 1
%22 = trunc i32 %21 to i8
store i8 %22, i8* %8
store i8 %22, i8* %9
store i32 0, i32* %11
br label %23
23: ; preds = %38, %19
%24 = load i32, i32* %11
%25 = load i32, i32* %7
%26 = icmp ult i32 %24, %25
br i1 %26, label %27, label %41
27: ; preds = %23
%28 = load i8*, i8** %10
%29 = load i32, i32* %11
%30 = zext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = load i8, i8* %9
%35 = zext i8 %34 to i32
%36 = xor i32 %35, %33
%37 = trunc i32 %36 to i8
store i8 %37, i8* %9
br label %38
38: ; preds = %27
%39 = load i32, i32* %11
%40 = add i32 %39, 1
store i32 %40, i32* %11
br label %23
41: ; preds = %23
%42 = load i32, i32* %5
%43 = call i32 @write(i32 %42, i8* %8, i32 1)
%44 = icmp ne i32 %43, 1
br i1 %44, label %45, label %46
45: ; preds = %41
store i32 -1, i32* %4
br label %65
46: ; preds = %41
%47 = load i32, i32* %5
%48 = load i8*, i8** %10
%49 = load i32, i32* %7
%50 = call i32 @write(i32 %47, i8* %48, i32 %49)
%51 = load i32, i32* %7
%52 = icmp ne i32 %50, %51
br i1 %52, label %53, label %54
53: ; preds = %46
store i32 -1, i32* %4
br label %65
54: ; preds = %46
%55 = load i32, i32* %5
%56 = call i32 @write(i32 %55, i8* %9, i32 1)
%57 = icmp ne i32 %56, 1
br i1 %57, label %58, label %59
58: ; preds = %54
store i32 -1, i32* %4
br label %65
59: ; preds = %54
%60 = load i32, i32* %5
%61 = call i64 @readAck(i32 %60)
%62 = icmp ne i64 %61, 0
br i1 %62, label %63, label %64
63: ; preds = %59
store i32 -1, i32* %4
br label %65
64: ; preds = %59
store i32 0, i32* %4
br label %65
65: ; preds = %64, %63, %58, %53, %45, %18
%66 = load i32, i32* %4
ret i32 %66
}

LLVM IR (-O2):
define i32 @sendData(i32 %0, i8* nocapture %1, i32 %2) {
%4 = alloca i8
%5 = alloca i8
%6 = add i32 %2, -257
%7 = icmp ult i32 %6, -256
br i1 %7, label %145, label %8
8: ; preds = %3
%9 = trunc i32 %2 to i8
%10 = add i8 %9, -1
store i8 %10, i8* %4
%11 = zext i32 %2 to i64
%12 = icmp ult i32 %2, 8
br i1 %12, label %120, label %13
13: ; preds = %8
%14 = icmp ult i32 %2, 32
br i1 %14, label %103, label %15
15: ; preds = %13
%16 = and i64 %11, 4294967264
%17 = insertelement <16 x i8> <i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %10, i64 0
%18 = bitcast i8* %1 to <16 x i8>*
%19 = load <16 x i8>, <16 x i8>* %18
%20 = getelementptr inbounds i8, i8* %1, i64 16
%21 = bitcast i8* %20 to <16 x i8>*
%22 = load <16 x i8>, <16 x i8>* %21
%23 = xor <16 x i8> %17, %19
%24 = icmp eq i64 %16, 32
br i1 %24, label %94, label %25
25: ; preds = %15
%26 = getelementptr inbounds i8, i8* %1, i64 32
%27 = bitcast i8* %26 to <16 x i8>*
%28 = load <16 x i8>, <16 x i8>* %27
%29 = getelementptr inbounds i8, i8* %1, i64 48
%30 = bitcast i8* %29 to <16 x i8>*
%31 = load <16 x i8>, <16 x i8>* %30
%32 = xor <16 x i8> %23, %28
%33 = xor <16 x i8> %22, %31
%34 = icmp eq i64 %16, 64
br i1 %34, label %94, label %35
35: ; preds = %25
%36 = getelementptr inbounds i8, i8* %1, i64 64
%37 = bitcast i8* %36 to <16 x i8>*
%38 = load <16 x i8>, <16 x i8>* %37
%39 = getelementptr inbounds i8, i8* %1, i64 80
%40 = bitcast i8* %39 to <16 x i8>*
%41 = load <16 x i8>, <16 x i8>* %40
%42 = xor <16 x i8> %32, %38
%43 = xor <16 x i8> %33, %41
%44 = icmp eq i64 %16, 96
br i1 %44, label %94, label %45
45: ; preds = %35
%46 = getelementptr inbounds i8, i8* %1, i64 96
%47 = bitcast i8* %46 to <16 x i8>*
%48 = load <16 x i8>, <16 x i8>* %47
%49 = getelementptr inbounds i8, i8* %1, i64 112
%50 = bitcast i8* %49 to <16 x i8>*
%51 = load <16 x i8>, <16 x i8>* %50
%52 = xor <16 x i8> %42, %48
%53 = xor <16 x i8> %43, %51
%54 = icmp eq i64 %16, 128
br i1 %54, label %94, label %55
55: ; preds = %45
%56 = getelementptr inbounds i8, i8* %1, i64 128
%57 = bitcast i8* %56 to <16 x i8>*
%58 = load <16 x i8>, <16 x i8>* %57
%59 = getelementptr inbounds i8, i8* %1, i64 144
%60 = bitcast i8* %59 to <16 x i8>*
%61 = load <16 x i8>, <16 x i8>* %60
%62 = xor <16 x i8> %52, %58
%63 = xor <16 x i8> %53, %61
%64 = icmp eq i64 %16, 160
br i1 %64, label %94, label %65
65: ; preds = %55
%66 = getelementptr inbounds i8, i8* %1, i64 160
%67 = bitcast i8* %66 to <16 x i8>*
%68 = load <16 x i8>, <16 x i8>* %67
%69 = getelementptr inbounds i8, i8* %1, i64 176
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = xor <16 x i8> %62, %68
%73 = xor <16 x i8> %63, %71
%74 = icmp eq i64 %16, 192
br i1 %74, label %94, label %75
75: ; preds = %65
%76 = getelementptr inbounds i8, i8* %1, i64 192
%77 = bitcast i8* %76 to <16 x i8>*
%78 = load <16 x i8>, <16 x i8>* %77
%79 = getelementptr inbounds i8, i8* %1, i64 208
%80 = bitcast i8* %79 to <16 x i8>*
%81 = load <16 x i8>, <16 x i8>* %80
%82 = xor <16 x i8> %72, %78
%83 = xor <16 x i8> %73, %81
%84 = icmp eq i64 %16, 224
br i1 %84, label %94, label %85
85: ; preds = %75
%86 = getelementptr inbounds i8, i8* %1, i64 224
%87 = bitcast i8* %86 to <16 x i8>*
%88 = load <16 x i8>, <16 x i8>* %87
%89 = getelementptr inbounds i8, i8* %1, i64 240
%90 = bitcast i8* %89 to <16 x i8>*
%91 = load <16 x i8>, <16 x i8>* %90
%92 = xor <16 x i8> %82, %88
%93 = xor <16 x i8> %83, %91
br label %94
94: ; preds = %85, %75, %65, %55, %45, %35, %25, %15
%95 = phi <16 x i8> [ %23, %15 ], [ %32, %25 ], [ %42, %35 ], [ %52, %45 ], [ %62, %55 ], [ %72, %65 ], [ %82, %75 ], [ %92, %85 ]
%96 = phi <16 x i8> [ %22, %15 ], [ %33, %25 ], [ %43, %35 ], [ %53, %45 ], [ %63, %55 ], [ %73, %65 ], [ %83, %75 ], [ %93, %85 ]
%97 = xor <16 x i8> %96, %95
%98 = call i8 @llvm.vector.reduce.xor.v16i8(<16 x i8> %97)
%99 = icmp eq i64 %16, %11
br i1 %99, label %131, label %100
100: ; preds = %94
%101 = and i64 %11, 24
%102 = icmp eq i64 %101, 0
br i1 %102, label %120, label %103
103: ; preds = %13, %100
%104 = phi i8 [ %10, %13 ], [ %98, %100 ]
%105 = phi i64 [ 0, %13 ], [ %16, %100 ]
%106 = and i64 %11, 4294967288
%107 = insertelement <8 x i8> <i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %104, i64 0
br label %108
108: ; preds = %108, %103
%109 = phi i64 [ %105, %103 ], [ %115, %108 ]
%110 = phi <8 x i8> [ %107, %103 ], [ %114, %108 ]
%111 = getelementptr inbounds i8, i8* %1, i64 %109
%112 = bitcast i8* %111 to <8 x i8>*
%113 = load <8 x i8>, <8 x i8>* %112
%114 = xor <8 x i8> %110, %113
%115 = add nuw i64 %109, 8
%116 = icmp eq i64 %115, %106
br i1 %116, label %117, label %108
117: ; preds = %108
%118 = call i8 @llvm.vector.reduce.xor.v8i8(<8 x i8> %114)
%119 = icmp eq i64 %106, %11
br i1 %119, label %131, label %120
120: ; preds = %8, %100, %117
%121 = phi i64 [ 0, %8 ], [ %16, %100 ], [ %106, %117 ]
%122 = phi i8 [ %10, %8 ], [ %98, %100 ], [ %118, %117 ]
br label %123
123: ; preds = %120, %123
%124 = phi i64 [ %129, %123 ], [ %121, %120 ]
%125 = phi i8 [ %128, %123 ], [ %122, %120 ]
%126 = getelementptr inbounds i8, i8* %1, i64 %124
%127 = load i8, i8* %126
%128 = xor i8 %125, %127
%129 = add nuw nsw i64 %124, 1
%130 = icmp eq i64 %129, %11
br i1 %130, label %131, label %123
131: ; preds = %123, %117, %94
%132 = phi i8 [ %98, %94 ], [ %118, %117 ], [ %128, %123 ]
store i8 %132, i8* %5
%133 = call i32 @write(i32 %0, i8* %4, i32 1)
%134 = icmp eq i32 %133, 1
br i1 %134, label %135, label %145
135: ; preds = %131
%136 = tail call i32 @write(i32 %0, i8* %1, i32 %2)
%137 = icmp eq i32 %136, %2
br i1 %137, label %138, label %145
138: ; preds = %135
%139 = call i32 @write(i32 %0, i8* %5, i32 1)
%140 = icmp eq i32 %139, 1
br i1 %140, label %141, label %145
141: ; preds = %138
%142 = tail call i64 @readAck(i32 %0)
%143 = icmp ne i64 %142, 0
%144 = sext i1 %143 to i32
br label %145
145: ; preds = %141, %138, %135, %131, %3
%146 = phi i32 [ -1, %3 ], [ -1, %131 ], [ -1, %135 ], [ -1, %138 ], [ %144, %141 ]
ret i32 %146
}