void RC5_Block_Encrypt(unsigned int *S, int R, unsigned char *in,
                       unsigned char *out) {
  int i;
  unsigned int A, B;
  A = in[0] & 0xFF;
  A += (in[1] & 0xFF) << 8;
  A += (in[2] & 0xFF) << 16;
  A += (in[3] & 0xFF) << 24;
  B = in[4] & 0xFF;
  B += (in[5] & 0xFF) << 8;
  B += (in[6] & 0xFF) << 16;
  B += (in[7] & 0xFF) << 24;
  A = A + S[0];
  B = B + S[1];
  for (i = 1; i <= R; i++) {
    A = A ^ B;
    A = ((unsigned int)(((unsigned int)(((A)) << (((B)) & ((32) - 1)))) |
                        ((unsigned int)(((A)) >>
                                        ((((32))) - (((B)) & ((32) - 1))))))) +
        S[2 * i];
    B = B ^ A;
    B = ((unsigned int)(((unsigned int)(((B)) << (((A)) & ((32) - 1)))) |
                        ((unsigned int)(((B)) >>
                                        ((((32))) - (((A)) & ((32) - 1))))))) +
        S[(2 * i) + 1];
  }
  out[0] = (A >> 0) & 0xFF;
  out[1] = (A >> 8) & 0xFF;
  out[2] = (A >> 16) & 0xFF;
  out[3] = (A >> 24) & 0xFF;
  out[4] = (B >> 0) & 0xFF;
  out[5] = (B >> 8) & 0xFF;
  out[6] = (B >> 16) & 0xFF;
  out[7] = (B >> 24) & 0xFF;
  return;
}


x86 assembly (clang, -O0):
<RC5_Block_Encrypt>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
and    $0xff,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xff,%eax
shl    $0x8,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xff,%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xff,%eax
shl    $0x18,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0xff,%eax
shl    $0x8,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0xff,%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0xff,%eax
shl    $0x18,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%rcx
add    (%rcx),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
add    0x4(%rcx),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     126d <RC5_Block_Encrypt+0x16d>
mov    -0x28(%rbp),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x2c(%rbp),%ecx
and    $0x1f,%ecx
shl    %cl,%eax
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%esi
and    $0x1f,%esi
mov    $0x20,%ecx
sub    %esi,%ecx
shr    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
and    $0x1f,%ecx
shl    %cl,%eax
mov    -0x2c(%rbp),%edx
mov    -0x28(%rbp),%esi
and    $0x1f,%esi
mov    $0x20,%ecx
sub    %esi,%ecx
shr    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11d6 <RC5_Block_Encrypt+0xd6>
mov    -0x28(%rbp),%eax
shr    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x28(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x28(%rbp),%eax
shr    $0x18,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x2c(%rbp),%eax
shr    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x2c(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x5(%rax)
mov    -0x2c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x6(%rax)
mov    -0x2c(%rbp),%eax
shr    $0x18,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x7(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RC5_Block_Encrypt>:
push   %rbp
push   %rbx
mov    %rcx,%rbp
mov    (%rdi),%ebx
add    (%rdx),%ebx
mov    0x4(%rdx),%edx
add    0x4(%rdi),%edx
test   %esi,%esi
jle    1181 <RC5_Block_Encrypt+0x81>
mov    %esi,%r8d
cmp    $0x1,%esi
jne    1122 <RC5_Block_Encrypt+0x22>
mov    $0x2,%esi
jmp    1161 <RC5_Block_Encrypt+0x61>
mov    %r8d,%eax
and    $0xfffffffe,%eax
mov    $0x2,%esi
nopl   (%rax)
xor    %edx,%ebx
mov    %edx,%ecx
rol    %cl,%ebx
add    (%rdi,%rsi,4),%ebx
xor    %ebx,%edx
mov    %ebx,%ecx
rol    %cl,%edx
add    0x4(%rdi,%rsi,4),%edx
xor    %edx,%ebx
mov    %edx,%ecx
rol    %cl,%ebx
add    0x8(%rdi,%rsi,4),%ebx
xor    %ebx,%edx
mov    %ebx,%ecx
rol    %cl,%edx
add    0xc(%rdi,%rsi,4),%edx
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rax
jne    1130 <RC5_Block_Encrypt+0x30>
test   $0x1,%r8b
je     1181 <RC5_Block_Encrypt+0x81>
xor    %edx,%ebx
mov    %edx,%ecx
rol    %cl,%ebx
add    (%rdi,%rsi,4),%ebx
xor    %ebx,%edx
mov    %ebx,%ecx
rol    %cl,%edx
shl    $0x2,%rsi
or     $0x4,%rsi
add    (%rdi,%rsi,1),%edx
mov    %bl,0x0(%rbp)
mov    %bh,0x1(%rbp)
mov    %ebx,%eax
shr    $0x10,%eax
mov    %al,0x2(%rbp)
shr    $0x18,%ebx
mov    %bl,0x3(%rbp)
mov    %dl,0x4(%rbp)
mov    %dh,0x5(%rbp)
mov    %edx,%eax
shr    $0x10,%eax
mov    %al,0x6(%rbp)
shr    $0x18,%edx
mov    %dl,0x7(%rbp)
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define void @RC5_Block_Encrypt(i32* %0, i32 %1, i8* %2, i8* %3) {
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i32* %0, i32** %5
store i32 %1, i32* %6
store i8* %2, i8** %7
store i8* %3, i8** %8
%12 = load i8*, i8** %7
%13 = getelementptr inbounds i8, i8* %12, i64 0
%14 = load i8, i8* %13
%15 = zext i8 %14 to i32
%16 = and i32 %15, 255
store i32 %16, i32* %10
%17 = load i8*, i8** %7
%18 = getelementptr inbounds i8, i8* %17, i64 1
%19 = load i8, i8* %18
%20 = zext i8 %19 to i32
%21 = and i32 %20, 255
%22 = shl i32 %21, 8
%23 = load i32, i32* %10
%24 = add i32 %23, %22
store i32 %24, i32* %10
%25 = load i8*, i8** %7
%26 = getelementptr inbounds i8, i8* %25, i64 2
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
%29 = and i32 %28, 255
%30 = shl i32 %29, 16
%31 = load i32, i32* %10
%32 = add i32 %31, %30
store i32 %32, i32* %10
%33 = load i8*, i8** %7
%34 = getelementptr inbounds i8, i8* %33, i64 3
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
%37 = and i32 %36, 255
%38 = shl i32 %37, 24
%39 = load i32, i32* %10
%40 = add i32 %39, %38
store i32 %40, i32* %10
%41 = load i8*, i8** %7
%42 = getelementptr inbounds i8, i8* %41, i64 4
%43 = load i8, i8* %42
%44 = zext i8 %43 to i32
%45 = and i32 %44, 255
store i32 %45, i32* %11
%46 = load i8*, i8** %7
%47 = getelementptr inbounds i8, i8* %46, i64 5
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = and i32 %49, 255
%51 = shl i32 %50, 8
%52 = load i32, i32* %11
%53 = add i32 %52, %51
store i32 %53, i32* %11
%54 = load i8*, i8** %7
%55 = getelementptr inbounds i8, i8* %54, i64 6
%56 = load i8, i8* %55
%57 = zext i8 %56 to i32
%58 = and i32 %57, 255
%59 = shl i32 %58, 16
%60 = load i32, i32* %11
%61 = add i32 %60, %59
store i32 %61, i32* %11
%62 = load i8*, i8** %7
%63 = getelementptr inbounds i8, i8* %62, i64 7
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = and i32 %65, 255
%67 = shl i32 %66, 24
%68 = load i32, i32* %11
%69 = add i32 %68, %67
store i32 %69, i32* %11
%70 = load i32, i32* %10
%71 = load i32*, i32** %5
%72 = getelementptr inbounds i32, i32* %71, i64 0
%73 = load i32, i32* %72
%74 = add i32 %70, %73
store i32 %74, i32* %10
%75 = load i32, i32* %11
%76 = load i32*, i32** %5
%77 = getelementptr inbounds i32, i32* %76, i64 1
%78 = load i32, i32* %77
%79 = add i32 %75, %78
store i32 %79, i32* %11
store i32 1, i32* %9
br label %80
80: ; preds = %126, %4
%81 = load i32, i32* %9
%82 = load i32, i32* %6
%83 = icmp sle i32 %81, %82
br i1 %83, label %84, label %129
84: ; preds = %80
%85 = load i32, i32* %10
%86 = load i32, i32* %11
%87 = xor i32 %85, %86
store i32 %87, i32* %10
%88 = load i32, i32* %10
%89 = load i32, i32* %11
%90 = and i32 %89, 31
%91 = shl i32 %88, %90
%92 = load i32, i32* %10
%93 = load i32, i32* %11
%94 = and i32 %93, 31
%95 = sub i32 32, %94
%96 = lshr i32 %92, %95
%97 = or i32 %91, %96
%98 = load i32*, i32** %5
%99 = load i32, i32* %9
%100 = mul nsw i32 2, %99
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %98, i64 %101
%103 = load i32, i32* %102
%104 = add i32 %97, %103
store i32 %104, i32* %10
%105 = load i32, i32* %11
%106 = load i32, i32* %10
%107 = xor i32 %105, %106
store i32 %107, i32* %11
%108 = load i32, i32* %11
%109 = load i32, i32* %10
%110 = and i32 %109, 31
%111 = shl i32 %108, %110
%112 = load i32, i32* %11
%113 = load i32, i32* %10
%114 = and i32 %113, 31
%115 = sub i32 32, %114
%116 = lshr i32 %112, %115
%117 = or i32 %111, %116
%118 = load i32*, i32** %5
%119 = load i32, i32* %9
%120 = mul nsw i32 2, %119
%121 = add nsw i32 %120, 1
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %118, i64 %122
%124 = load i32, i32* %123
%125 = add i32 %117, %124
store i32 %125, i32* %11
br label %126
126: ; preds = %84
%127 = load i32, i32* %9
%128 = add nsw i32 %127, 1
store i32 %128, i32* %9
br label %80
129: ; preds = %80
%130 = load i32, i32* %10
%131 = lshr i32 %130, 0
%132 = and i32 %131, 255
%133 = trunc i32 %132 to i8
%134 = load i8*, i8** %8
%135 = getelementptr inbounds i8, i8* %134, i64 0
store i8 %133, i8* %135
%136 = load i32, i32* %10
%137 = lshr i32 %136, 8
%138 = and i32 %137, 255
%139 = trunc i32 %138 to i8
%140 = load i8*, i8** %8
%141 = getelementptr inbounds i8, i8* %140, i64 1
store i8 %139, i8* %141
%142 = load i32, i32* %10
%143 = lshr i32 %142, 16
%144 = and i32 %143, 255
%145 = trunc i32 %144 to i8
%146 = load i8*, i8** %8
%147 = getelementptr inbounds i8, i8* %146, i64 2
store i8 %145, i8* %147
%148 = load i32, i32* %10
%149 = lshr i32 %148, 24
%150 = and i32 %149, 255
%151 = trunc i32 %150 to i8
%152 = load i8*, i8** %8
%153 = getelementptr inbounds i8, i8* %152, i64 3
store i8 %151, i8* %153
%154 = load i32, i32* %11
%155 = lshr i32 %154, 0
%156 = and i32 %155, 255
%157 = trunc i32 %156 to i8
%158 = load i8*, i8** %8
%159 = getelementptr inbounds i8, i8* %158, i64 4
store i8 %157, i8* %159
%160 = load i32, i32* %11
%161 = lshr i32 %160, 8
%162 = and i32 %161, 255
%163 = trunc i32 %162 to i8
%164 = load i8*, i8** %8
%165 = getelementptr inbounds i8, i8* %164, i64 5
store i8 %163, i8* %165
%166 = load i32, i32* %11
%167 = lshr i32 %166, 16
%168 = and i32 %167, 255
%169 = trunc i32 %168 to i8
%170 = load i8*, i8** %8
%171 = getelementptr inbounds i8, i8* %170, i64 6
store i8 %169, i8* %171
%172 = load i32, i32* %11
%173 = lshr i32 %172, 24
%174 = and i32 %173, 255
%175 = trunc i32 %174 to i8
%176 = load i8*, i8** %8
%177 = getelementptr inbounds i8, i8* %176, i64 7
store i8 %175, i8* %177
ret void
}

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