char *Q_UTF8Encode(unsigned long codepoint) {
  static char sbuf[2][5];
  static int index = 0;
  char *buf = sbuf[index++ & 1];
  if (codepoint <= 0x007F) {
    buf[0] = codepoint;
    buf[1] = 0;
  } else if (0x0080 <= codepoint && codepoint <= 0x07FF) {
    buf[0] = 0xC0 | ((codepoint & 0x0700) >> 6) | ((codepoint & 0x00C0) >> 6);
    buf[1] = 0x80 | (codepoint & 0x003F);
    buf[2] = 0;
  } else if (0x0800 <= codepoint && codepoint <= 0xFFFF) {
    buf[0] = 0xE0 | ((codepoint & 0xF000) >> 12);
    buf[1] = 0x80 | ((codepoint & 0x0F00) >> 6) | ((codepoint & 0x00C0) >> 6);
    buf[2] = 0x80 | (codepoint & 0x003F);
    buf[3] = 0;
  } else if (0x010000 <= codepoint && codepoint <= 0x10FFFF) {
    buf[0] = 0xF0 | ((codepoint & 0x1C0000 >> 18));
    buf[1] =
        0x80 | ((codepoint & 0x030000 >> 16)) | ((codepoint & 0x00F000) >> 12);
    buf[2] =
        0x80 | ((codepoint & 0x000F00) >> 6) | ((codepoint & 0x0000C0) >> 6);
    buf[3] = 0x80 | (codepoint & 0x00003F);
    buf[4] = 0;
  } else {
    buf[0] = 0;
  }
  return buf;
}


x86 assembly (clang, -O0):
<Q_UTF8Encode>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    0x2f22(%rip),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,0x2f17(%rip)
and    $0x1,%eax
movslq %eax,%rcx
lea    0x2efe(%rip),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
cmpq   $0x7f,-0x8(%rbp)
ja     1155 <Q_UTF8Encode+0x55>
mov    -0x8(%rbp),%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0x1(%rax)
jmp    1315 <Q_UTF8Encode+0x215>
mov    $0x80,%eax
cmp    -0x8(%rbp),%rax
ja     11c4 <Q_UTF8Encode+0xc4>
cmpq   $0x7ff,-0x8(%rbp)
ja     11c4 <Q_UTF8Encode+0xc4>
mov    -0x8(%rbp),%rax
and    $0x700,%rax
shr    $0x6,%rax
or     $0xc0,%rax
mov    -0x8(%rbp),%rcx
and    $0xc0,%rcx
shr    $0x6,%rcx
or     %rcx,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0x2(%rax)
jmp    1310 <Q_UTF8Encode+0x210>
mov    $0x800,%eax
cmp    -0x8(%rbp),%rax
ja     1250 <Q_UTF8Encode+0x150>
cmpq   $0xffff,-0x8(%rbp)
ja     1250 <Q_UTF8Encode+0x150>
mov    -0x8(%rbp),%rax
and    $0xf000,%rax
shr    $0xc,%rax
or     $0xe0,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
and    $0xf00,%rax
shr    $0x6,%rax
or     $0x80,%rax
mov    -0x8(%rbp),%rcx
and    $0xc0,%rcx
shr    $0x6,%rcx
or     %rcx,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0x3(%rax)
jmp    130b <Q_UTF8Encode+0x20b>
mov    $0x10000,%eax
cmp    -0x8(%rbp),%rax
ja     12ff <Q_UTF8Encode+0x1ff>
cmpq   $0x10ffff,-0x8(%rbp)
ja     12ff <Q_UTF8Encode+0x1ff>
mov    -0x8(%rbp),%rax
and    $0x7,%rax
or     $0xf0,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
and    $0x3,%rax
or     $0x80,%rax
mov    -0x8(%rbp),%rcx
and    $0xf000,%rcx
shr    $0xc,%rcx
or     %rcx,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
and    $0xf00,%rax
shr    $0x6,%rax
or     $0x80,%rax
mov    -0x8(%rbp),%rcx
and    $0xc0,%rcx
shr    $0x6,%rcx
or     %rcx,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0x4(%rax)
jmp    1306 <Q_UTF8Encode+0x206>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
jmp    130b <Q_UTF8Encode+0x20b>
jmp    1310 <Q_UTF8Encode+0x210>
jmp    1315 <Q_UTF8Encode+0x215>
mov    -0x10(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Q_UTF8Encode>:
mov    0x2f2a(%rip),%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x2f21(%rip)
and    $0x1,%eax
lea    (%rax,%rax,4),%rcx
lea    0x2f07(%rip),%r8
lea    (%r8,%rcx,1),%rax
cmp    $0x7f,%rdi
ja     1136 <Q_UTF8Encode+0x36>
mov    %dil,(%rax)
lea    (%r8,%rcx,1),%rsi
add    $0x1,%rsi
movb   $0x0,(%rsi)
ret
cmp    $0x7ff,%rdi
ja     1166 <Q_UTF8Encode+0x66>
mov    %rdi,%rsi
shr    $0x6,%rsi
or     $0xc0,%sil
mov    %sil,(%rax)
and    $0x3f,%dil
or     $0x80,%dil
mov    %dil,0x1(%r8,%rcx,1)
lea    (%r8,%rcx,1),%rsi
add    $0x2,%rsi
movb   $0x0,(%rsi)
ret
cmp    $0xffff,%rdi
ja     11aa <Q_UTF8Encode+0xaa>
mov    %rdi,%rsi
shr    $0xc,%rsi
or     $0xe0,%sil
mov    %sil,(%rax)
mov    %rdi,%rsi
shr    $0x6,%rsi
and    $0x3f,%sil
or     $0x80,%sil
mov    %sil,0x1(%r8,%rcx,1)
and    $0x3f,%dil
or     $0x80,%dil
mov    %dil,0x2(%r8,%rcx,1)
lea    (%r8,%rcx,1),%rsi
add    $0x3,%rsi
movb   $0x0,(%rsi)
ret
mov    %rax,%rsi
cmp    $0x10ffff,%rdi
ja     11ff <Q_UTF8Encode+0xff>
mov    %edi,%edx
and    $0x7,%dl
or     $0xf0,%dl
mov    %dl,(%rax)
mov    %edi,%edx
and    $0x3,%edx
mov    %edi,%esi
shr    $0xc,%esi
and    $0xf,%esi
or     %edx,%esi
or     $0x80,%sil
mov    %sil,0x1(%r8,%rcx,1)
mov    %rdi,%rdx
shr    $0x6,%rdx
and    $0x3f,%dl
or     $0x80,%dl
mov    %dl,0x2(%r8,%rcx,1)
and    $0x3f,%dil
or     $0x80,%dil
mov    %dil,0x3(%r8,%rcx,1)
lea    (%r8,%rcx,1),%rsi
add    $0x4,%rsi
movb   $0x0,(%rsi)
ret

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

LLVM IR (-O2):
@Q_UTF8Encode.sbuf = internal global [2 x [5 x i8]] zeroinitializer
@Q_UTF8Encode.index = internal unnamed_addr global i32 0
define i8* @Q_UTF8Encode(i64 %0) {
%2 = load i32, i32* @Q_UTF8Encode.index
%3 = add nsw i32 %2, 1
store i32 %3, i32* @Q_UTF8Encode.index
%4 = and i32 %2, 1
%5 = zext i32 %4 to i64
%6 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 0
%7 = icmp ult i64 %0, 128
br i1 %7, label %8, label %11
8: ; preds = %1
%9 = trunc i64 %0 to i8
store i8 %9, i8* %6
%10 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 1
br label %60
11: ; preds = %1
%12 = icmp ult i64 %0, 2048
br i1 %12, label %13, label %22
13: ; preds = %11
%14 = lshr i64 %0, 6
%15 = trunc i64 %14 to i8
%16 = or i8 %15, -64
store i8 %16, i8* %6
%17 = trunc i64 %0 to i8
%18 = and i8 %17, 63
%19 = or i8 %18, -128
%20 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 1
store i8 %19, i8* %20
%21 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 2
br label %60
22: ; preds = %11
%23 = icmp ult i64 %0, 65536
br i1 %23, label %24, label %38
24: ; preds = %22
%25 = lshr i64 %0, 12
%26 = trunc i64 %25 to i8
%27 = or i8 %26, -32
store i8 %27, i8* %6
%28 = lshr i64 %0, 6
%29 = trunc i64 %28 to i8
%30 = and i8 %29, 63
%31 = or i8 %30, -128
%32 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 1
store i8 %31, i8* %32
%33 = trunc i64 %0 to i8
%34 = and i8 %33, 63
%35 = or i8 %34, -128
%36 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 2
store i8 %35, i8* %36
%37 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 3
br label %60
38: ; preds = %22
%39 = icmp ult i64 %0, 1114112
br i1 %39, label %40, label %60
40: ; preds = %38
%41 = trunc i64 %0 to i8
%42 = and i8 %41, 7
%43 = or i8 %42, -16
store i8 %43, i8* %6
%44 = and i64 %0, 3
%45 = lshr i64 %0, 12
%46 = and i64 %45, 15
%47 = or i64 %46, %44
%48 = trunc i64 %47 to i8
%49 = or i8 %48, -128
%50 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 1
store i8 %49, i8* %50
%51 = lshr i64 %0, 6
%52 = trunc i64 %51 to i8
%53 = and i8 %52, 63
%54 = or i8 %53, -128
%55 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 2
store i8 %54, i8* %55
%56 = and i8 %41, 63
%57 = or i8 %56, -128
%58 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 3
store i8 %57, i8* %58
%59 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* @Q_UTF8Encode.sbuf, i64 0, i64 %5, i64 4
br label %60
60: ; preds = %38, %13, %40, %24, %8
%61 = phi i8* [ %21, %13 ], [ %59, %40 ], [ %37, %24 ], [ %10, %8 ], [ %6, %38 ]
store i8 0, i8* %61
ret i8* %6
}