#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 unsigned int uint8_t;
typedef scalar_t__ uint32_t;

/* Variables and functions */
uint32_t rotate_glyph(const uint8_t *glyph, unsigned gw, int gh,
                      uint8_t *grot) {
  uint32_t dy = 0;
  do {
    for (uint8_t n = 0; n < gw; n++) {
      uint8_t out = 0;
      uint8_t mask = 0x80 >> n;
      for (uint8_t b = 0; b < 8; b++) {
        if (glyph[b] & mask)
          out |= 1 << b;
      }
      grot[dy++] = out;
    }
    glyph += 8;
  } while ((gh -= 8) > 0);
  return dy;
}


x86 assembly (clang, -O0):
<rotate_glyph>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11b2 <rotate_glyph+0xb2>
movl   $0x0,-0x28(%rbp)
mov    -0x24(%rbp),%ecx
mov    $0x80,%eax
sar    %cl,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jae    118b <rotate_glyph+0x8b>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
and    -0x2c(%rbp),%eax
cmp    $0x0,%eax
je     1178 <rotate_glyph+0x78>
mov    -0x30(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    117d <rotate_glyph+0x7d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1148 <rotate_glyph+0x48>
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x20(%rbp)
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1121 <rotate_glyph+0x21>
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x10(%rbp)
cmp    $0x0,%eax
jg     111a <rotate_glyph+0x1a>
mov    -0x20(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<rotate_glyph>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%r8
lea    -0x1(%rsi),%r9d
lea    0x4(%rcx,%r9,4),%rax
mov    %rax,-0x60(%rsp)
lea    0x1(%r9),%r14
mov    %r14,-0x68(%rsp)
and    $0xfffffffffffffffc,%r14
xor    %r15d,%r15d
pxor   %xmm0,%xmm0
movdqa 0xed8(%rip),%xmm13
movdqa 0xee0(%rip),%xmm4
movdqa 0xee8(%rip),%xmm7
movdqa 0xef0(%rip),%xmm5
movdqa 0xef7(%rip),%xmm11
movdqa 0xefe(%rip),%xmm15
movdqa 0xf05(%rip),%xmm14
xor    %eax,%eax
mov    %rdi,%r13
jmp    1196 <rotate_glyph+0x96>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x20,%r13
lea    -0x8(%rdx),%ecx
add    $0x1,%r15
cmp    $0x8,%edx
mov    %ecx,%edx
jle    1447 <rotate_glyph+0x347>
test   %esi,%esi
je     1180 <rotate_glyph+0x80>
xor    %ecx,%ecx
cmp    $0x3,%r9d
jb     1390 <rotate_glyph+0x290>
mov    %r15,%rbx
shl    $0x5,%rbx
add    %rdi,%rbx
add    $0x20,%rbx
lea    (%r8,%rax,4),%r12
cmp    %rbx,%r12
jae    11d6 <rotate_glyph+0xd6>
mov    -0x60(%rsp),%rbp
lea    0x0(,%rax,4),%rbx
add    %rbp,%rbx
cmp    %rbx,%r13
jb     1390 <rotate_glyph+0x290>
add    %r14,%rax
movd   0x0(%r13),%xmm1
pshufd $0x0,%xmm1,%xmm1
movdqa %xmm1,-0x18(%rsp)
movd   0x4(%r13),%xmm1
pshufd $0x0,%xmm1,%xmm1
movdqa %xmm1,-0x28(%rsp)
movd   0x8(%r13),%xmm1
pshufd $0x0,%xmm1,%xmm1
movdqa %xmm1,-0x38(%rsp)
movd   0xc(%r13),%xmm1
pshufd $0x0,%xmm1,%xmm1
movdqa %xmm1,-0x48(%rsp)
movd   0x10(%r13),%xmm2
pshufd $0x0,%xmm2,%xmm1
movdqa %xmm1,-0x58(%rsp)
movd   0x14(%r13),%xmm2
pshufd $0x0,%xmm2,%xmm12
movd   0x18(%r13),%xmm2
pshufd $0x0,%xmm2,%xmm8
movd   0x1c(%r13),%xmm2
pshufd $0x0,%xmm2,%xmm9
xor    %ecx,%ecx
movdqa 0xda3(%rip),%xmm10
nopl   (%rax)
pshuflw $0xfe,%xmm10,%xmm2
movdqa %xmm13,%xmm3
psrld  %xmm2,%xmm3
pshuflw $0x54,%xmm10,%xmm6
movdqa %xmm13,%xmm2
psrld  %xmm6,%xmm2
punpcklqdq %xmm3,%xmm2
pshufd $0xee,%xmm10,%xmm3
pshuflw $0xfe,%xmm3,%xmm6
movdqa %xmm11,%xmm1
movdqa %xmm13,%xmm11
psrld  %xmm6,%xmm11
pshuflw $0x54,%xmm3,%xmm3
movdqa %xmm13,%xmm6
psrld  %xmm3,%xmm6
punpckhqdq %xmm11,%xmm6
movdqa %xmm1,%xmm11
pcmpeqd %xmm1,%xmm1
shufps $0xcc,%xmm6,%xmm2
movaps -0x18(%rsp),%xmm3
andps  %xmm2,%xmm3
pcmpeqd %xmm0,%xmm3
movaps -0x28(%rsp),%xmm6
andps  %xmm2,%xmm6
pcmpeqd %xmm0,%xmm6
pandn  %xmm4,%xmm6
paddd  %xmm3,%xmm6
psubd  %xmm1,%xmm6
movaps -0x38(%rsp),%xmm3
andps  %xmm2,%xmm3
pcmpeqd %xmm0,%xmm3
pandn  %xmm7,%xmm3
movaps -0x48(%rsp),%xmm1
andps  %xmm2,%xmm1
pcmpeqd %xmm0,%xmm1
pandn  %xmm5,%xmm1
por    %xmm3,%xmm1
movaps -0x58(%rsp),%xmm3
andps  %xmm2,%xmm3
pcmpeqd %xmm0,%xmm3
pandn  %xmm11,%xmm3
por    %xmm1,%xmm3
por    %xmm6,%xmm3
movdqa %xmm12,%xmm1
pand   %xmm2,%xmm1
pcmpeqd %xmm0,%xmm1
pandn  %xmm15,%xmm1
movdqa %xmm8,%xmm6
pand   %xmm2,%xmm6
pcmpeqd %xmm0,%xmm6
pandn  %xmm14,%xmm6
por    %xmm1,%xmm6
pand   %xmm9,%xmm2
pcmpeqd %xmm0,%xmm2
pandn  %xmm13,%xmm2
por    %xmm6,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,(%r12,%rcx,4)
add    $0x4,%rcx
paddd  %xmm7,%xmm10
cmp    %rcx,%r14
jne    1260 <rotate_glyph+0x160>
mov    %r14d,%ecx
cmp    %r14,-0x68(%rsp)
je     1180 <rotate_glyph+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x80,%ebp
shr    %cl,%ebp
xor    %r12d,%r12d
mov    0x0(%r13),%ebx
and    %ebp,%ebx
setne  %r12b
xor    %ebx,%ebx
mov    0x4(%r13),%r11d
and    %ebp,%r11d
setne  %bl
lea    (%r12,%rbx,2),%r11d
xor    %r12d,%r12d
mov    0x8(%r13),%ebx
and    %ebp,%ebx
setne  %r12b
xor    %ebx,%ebx
movd   %ebp,%xmm1
and    0xc(%r13),%ebp
lea    (%r11,%r12,4),%ebp
setne  %bl
lea    0x0(%rbp,%rbx,8),%r11d
movdqu 0x10(%r13),%xmm2
pshufd $0x0,%xmm1,%xmm1
pand   %xmm2,%xmm1
pcmpeqd %xmm0,%xmm1
movmskps %xmm1,%ebp
xor    %r12d,%r12d
test   $0x8,%bpl
sete   %r12b
xor    %ebx,%ebx
test   $0x4,%bpl
sete   %bl
xor    %r10d,%r10d
test   $0x2,%bpl
sete   %r10b
not    %bpl
movzbl %bpl,%ebp
and    $0x1,%ebp
shl    $0x4,%ebp
or     %r11d,%ebp
shl    $0x5,%r10d
shl    $0x6,%ebx
or     %r10d,%ebx
or     %ebp,%ebx
shl    $0x7,%r12d
or     %ebx,%r12d
mov    %r12d,(%r8,%rax,4)
add    $0x1,%rax
add    $0x1,%ecx
cmp    %ecx,%esi
jne    1390 <rotate_glyph+0x290>
jmp    1180 <rotate_glyph+0x80>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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