#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 rotl(char, unsigned short);
void bl_encrypt(char *block, unsigned short key) {
  int round, i;
  key %= 16;
  for (round = 0; round < 2; ++round) {
    for (i = 0; i < 8; i += 2) {
      *(block + i) ^= key + i + round;
      *(block + i) = rotl(*(block + i), ((unsigned short int)key) % 7);
    }
  }
}


x86 assembly (clang, -O0):
<bl_encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %si,%ax
mov    %rdi,-0x8(%rbp)
mov    %ax,-0xa(%rbp)
movzwl -0xa(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %dx,%ax
mov    %ax,-0xa(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x2,-0x10(%rbp)
jge    11c6 <bl_encrypt+0xb6>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8,-0x14(%rbp)
jge    11b3 <bl_encrypt+0xa3>
movzwl -0xa(%rbp),%esi
add    -0x14(%rbp),%esi
add    -0x10(%rbp),%esi
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movzwl -0xa(%rbp),%eax
mov    $0x7,%esi
cltd
idiv   %esi
mov    %dx,%ax
movsbl %cl,%edi
movzwl %ax,%esi
call   1030 <rotl@plt>
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    114e <bl_encrypt+0x3e>
jmp    11b8 <bl_encrypt+0xa8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    113d <bl_encrypt+0x2d>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bl_encrypt>:
push   %rbp
push   %r14
push   %rbx
mov    %esi,%r14d
mov    %rdi,%rbx
and    $0xf,%r14d
lea    (%r14,%r14,8),%eax
lea    (%r14,%rax,4),%eax
shr    $0x8,%eax
mov    %r14d,%ecx
sub    %al,%cl
shr    %cl
add    %al,%cl
shr    $0x2,%cl
movzbl %cl,%eax
lea    0x0(,%rax,8),%ecx
sub    %eax,%ecx
mov    %r14d,%eax
sub    %cl,%al
mov    (%rdi),%cl
xor    %r14b,%cl
mov    %cl,(%rdi)
movzbl %al,%ebp
movsbl %cl,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,(%rbx)
lea    0x2(%r14),%eax
xor    0x2(%rbx),%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,0x2(%rbx)
lea    0x4(%r14),%eax
xor    0x4(%rbx),%al
mov    %al,0x4(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,0x4(%rbx)
lea    0x6(%r14),%eax
xor    0x6(%rbx),%al
mov    %al,0x6(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,0x6(%rbx)
lea    0x1(%r14),%eax
xor    (%rbx),%al
mov    %al,(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,(%rbx)
lea    0x3(%r14),%eax
xor    0x2(%rbx),%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,0x2(%rbx)
lea    0x5(%r14),%eax
xor    0x4(%rbx),%al
mov    %al,0x4(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,0x4(%rbx)
lea    0x7(%r14),%eax
xor    0x6(%rbx),%al
mov    %al,0x6(%rbx)
movsbl %al,%edi
mov    %ebp,%esi
call   1030 <rotl@plt>
mov    %al,0x6(%rbx)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define void @bl_encrypt(i8* nocapture %0, i16 zeroext %1) {
%3 = and i16 %1, 15
%4 = trunc i16 %3 to i8
%5 = urem i8 %4, 7
%6 = zext i8 %5 to i16
%7 = load i8, i8* %0
%8 = trunc i16 %3 to i8
%9 = xor i8 %7, %8
store i8 %9, i8* %0
%10 = tail call signext i8 @rotl(i8 signext %9, i16 zeroext %6)
store i8 %10, i8* %0
%11 = getelementptr inbounds i8, i8* %0, i64 2
%12 = load i8, i8* %11
%13 = trunc i16 %3 to i8
%14 = add nuw nsw i8 %13, 2
%15 = xor i8 %12, %14
store i8 %15, i8* %11
%16 = tail call signext i8 @rotl(i8 signext %15, i16 zeroext %6)
store i8 %16, i8* %11
%17 = getelementptr inbounds i8, i8* %0, i64 4
%18 = load i8, i8* %17
%19 = trunc i16 %3 to i8
%20 = add nuw nsw i8 %19, 4
%21 = xor i8 %18, %20
store i8 %21, i8* %17
%22 = tail call signext i8 @rotl(i8 signext %21, i16 zeroext %6)
store i8 %22, i8* %17
%23 = getelementptr inbounds i8, i8* %0, i64 6
%24 = load i8, i8* %23
%25 = trunc i16 %3 to i8
%26 = add nuw nsw i8 %25, 6
%27 = xor i8 %24, %26
store i8 %27, i8* %23
%28 = tail call signext i8 @rotl(i8 signext %27, i16 zeroext %6)
store i8 %28, i8* %23
%29 = load i8, i8* %0
%30 = trunc i16 %3 to i8
%31 = add nuw nsw i8 %30, 1
%32 = xor i8 %29, %31
store i8 %32, i8* %0
%33 = tail call signext i8 @rotl(i8 signext %32, i16 zeroext %6)
store i8 %33, i8* %0
%34 = load i8, i8* %11
%35 = trunc i16 %3 to i8
%36 = add nuw nsw i8 %35, 3
%37 = xor i8 %34, %36
store i8 %37, i8* %11
%38 = tail call signext i8 @rotl(i8 signext %37, i16 zeroext %6)
store i8 %38, i8* %11
%39 = load i8, i8* %17
%40 = trunc i16 %3 to i8
%41 = add nuw nsw i8 %40, 5
%42 = xor i8 %39, %41
store i8 %42, i8* %17
%43 = tail call signext i8 @rotl(i8 signext %42, i16 zeroext %6)
store i8 %43, i8* %17
%44 = load i8, i8* %23
%45 = trunc i16 %3 to i8
%46 = add nuw nsw i8 %45, 7
%47 = xor i8 %44, %46
store i8 %47, i8* %23
%48 = tail call signext i8 @rotl(i8 signext %47, i16 zeroext %6)
store i8 %48, i8* %23
ret void
}