void gm_quadtree(int x, int y, int z, char *buffer) {
  static const char *const quadrant = "qrts";
  int i;
  char *ptr = buffer;
  *ptr++ = 't';
  for (i = z - 1; i >= 0; i--) {
    int xbit = (x >> i) & 1;
    int ybit = (y >> i) & 1;
    *ptr++ = quadrant[xbit + 2 * ybit];
  }
  *ptr++ = '\0';
}


x86 assembly (clang, -O0):
<gm_quadtree>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x74,(%rax)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     1191 <gm_quadtree+0x91>
mov    -0x4(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
movslq %eax,%rcx
lea    0xe91(%rip),%rax
mov    (%rax,%rcx,1),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1134 <gm_quadtree+0x34>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<gm_quadtree>:
movb   $0x74,(%rcx)
lea    0x1(%rcx),%r11
test   %edx,%edx
jle    11bb <gm_quadtree+0xbb>
mov    %rcx,%r8
mov    %edx,%r9d
test   $0x1,%dl
jne    1124 <gm_quadtree+0x24>
cmp    $0x1,%edx
jne    115a <gm_quadtree+0x5a>
movb   $0x0,(%r8)
ret
lea    -0x1(%rdx),%r9d
mov    %edi,%r10d
mov    %r9d,%ecx
shr    %cl,%r10d
mov    %esi,%eax
shr    %cl,%eax
and    $0x1,%r10d
and    $0x1,%eax
lea    (%r10,%rax,2),%eax
lea    0xeb9(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x1(%r8)
add    $0x2,%r8
mov    %r8,%r11
cmp    $0x1,%edx
je     111f <gm_quadtree+0x1f>
add    $0xfffffffe,%r9d
lea    0xe9b(%rip),%r8
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r9),%r10d
mov    %edi,%edx
mov    %r10d,%ecx
shr    %cl,%edx
mov    %esi,%eax
shr    %cl,%eax
and    $0x1,%edx
and    $0x1,%eax
lea    (%rdx,%rax,2),%eax
mov    %edi,%edx
mov    %r9d,%ecx
shr    %cl,%edx
movzbl (%rax,%r8,1),%eax
mov    %al,(%r11)
mov    %esi,%eax
shr    %cl,%eax
and    $0x1,%edx
and    $0x1,%eax
lea    (%rdx,%rax,2),%eax
movzbl (%rax,%r8,1),%eax
mov    %al,0x1(%r11)
add    $0x2,%r11
add    $0xfffffffe,%r9d
cmp    $0x1,%r10d
ja     1170 <gm_quadtree+0x70>
mov    %r11,%r8
movb   $0x0,(%r8)
ret

LLVM IR (-O0):
@gm_quadtree.quadrant = internal constant i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0)
@.str = [5 x i8] c"qrts\00"
define void @gm_quadtree(i32 %0, i32 %1, i32 %2, i8* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i8* %3, i8** %8
%13 = load i8*, i8** %8
store i8* %13, i8** %10
%14 = load i8*, i8** %10
%15 = getelementptr inbounds i8, i8* %14, i32 1
store i8* %15, i8** %10
store i8 116, i8* %14
%16 = load i32, i32* %7
%17 = sub nsw i32 %16, 1
store i32 %17, i32* %9
br label %18
18: ; preds = %39, %4
%19 = load i32, i32* %9
%20 = icmp sge i32 %19, 0
br i1 %20, label %21, label %42
21: ; preds = %18
%22 = load i32, i32* %5
%23 = load i32, i32* %9
%24 = ashr i32 %22, %23
%25 = and i32 %24, 1
store i32 %25, i32* %11
%26 = load i32, i32* %6
%27 = load i32, i32* %9
%28 = ashr i32 %26, %27
%29 = and i32 %28, 1
store i32 %29, i32* %12
%30 = load i32, i32* %11
%31 = load i32, i32* %12
%32 = mul nsw i32 2, %31
%33 = add nsw i32 %30, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i32 0, i32 0), i64 %34
%36 = load i8, i8* %35
%37 = load i8*, i8** %10
%38 = getelementptr inbounds i8, i8* %37, i32 1
store i8* %38, i8** %10
store i8 %36, i8* %37
br label %39
39: ; preds = %21
%40 = load i32, i32* %9
%41 = add nsw i32 %40, -1
store i32 %41, i32* %9
br label %18
42: ; preds = %18
%43 = load i8*, i8** %10
%44 = getelementptr inbounds i8, i8* %43, i32 1
store i8* %44, i8** %10
store i8 0, i8* %43
ret void
}

LLVM IR (-O2):
@.str = [5 x i8] c"qrts\00"
define void @gm_quadtree(i32 %0, i32 %1, i32 %2, i8* nocapture writeonly %3) {
store i8 116, i8* %3
%5 = getelementptr inbounds i8, i8* %3, i64 1
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %53
7: ; preds = %4
%8 = and i32 %2, 1
%9 = icmp eq i32 %8, 0
br i1 %9, label %22, label %10
10: ; preds = %7
%11 = add nsw i32 %2, -1
%12 = lshr i32 %0, %11
%13 = and i32 %12, 1
%14 = lshr i32 %1, %11
%15 = shl i32 %14, 1
%16 = and i32 %15, 2
%17 = or i32 %16, %13
%18 = zext i32 %17 to i64
%19 = getelementptr inbounds [5 x i8], [5 x i8]* @.str, i64 0, i64 %18
%20 = load i8, i8* %19
store i8 %20, i8* %5
%21 = getelementptr inbounds i8, i8* %3, i64 2
br label %22
22: ; preds = %10, %7
%23 = phi i32 [ %2, %7 ], [ %11, %10 ]
%24 = phi i8* [ %5, %7 ], [ %21, %10 ]
%25 = phi i8* [ undef, %7 ], [ %21, %10 ]
%26 = icmp eq i32 %2, 1
br i1 %26, label %53, label %27
27: ; preds = %22, %27
%28 = phi i32 [ %41, %27 ], [ %23, %22 ]
%29 = phi i8* [ %51, %27 ], [ %24, %22 ]
%30 = add nsw i32 %28, -1
%31 = lshr i32 %0, %30
%32 = and i32 %31, 1
%33 = lshr i32 %1, %30
%34 = shl i32 %33, 1
%35 = and i32 %34, 2
%36 = or i32 %35, %32
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds [5 x i8], [5 x i8]* @.str, i64 0, i64 %37
%39 = load i8, i8* %38
store i8 %39, i8* %29
%40 = getelementptr inbounds i8, i8* %29, i64 1
%41 = add nsw i32 %28, -2
%42 = lshr i32 %0, %41
%43 = and i32 %42, 1
%44 = lshr i32 %1, %41
%45 = shl i32 %44, 1
%46 = and i32 %45, 2
%47 = or i32 %46, %43
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds [5 x i8], [5 x i8]* @.str, i64 0, i64 %48
%50 = load i8, i8* %49
store i8 %50, i8* %40
%51 = getelementptr inbounds i8, i8* %29, i64 2
%52 = icmp ugt i32 %30, 1
br i1 %52, label %27, label %53
53: ; preds = %22, %27, %4
%54 = phi i8* [ %5, %4 ], [ %25, %22 ], [ %51, %27 ]
store i8 0, i8* %54
ret void
}