const char *Tuple_Description(void) {
  return "The `Tuple` type provides a basic way to create a simple collection "
         "of "
         "objects. Its main use is the fact that it can be constructed on the "
         "stack using the `tuple` macro. This makes it suitable for a number "
         "of "
         "purposes such as use in functions that take a variable number of "
         "arguments."
         "\n\n"
         "Tuples can also be constructed on the heap and stored in "
         "collections. "
         "This makes them also useful as a simple _untyped_ list of objects."
         "\n\n"
         "Internally Tuples are just an array of pointers terminated with a "
         "pointer "
         "to the Cello `Terminal` object. This makes positional access fast, "
         "but "
         "many other operations slow including iteration and counting the "
         "number of "
         "elements. Due to this it is only recommended Tuples are used for "
         "small "
         "collections. "
         "\n\n"
         "Because Tuples are terminated with the Cello `Terminal` object this "
         "can't "
         "naturally be included within them. This object should therefore only "
         "be "
         "returned from iteration functions.";
}


x86 assembly (clang, -O0):
<Tuple_Description>:
push   %rbp
mov    %rsp,%rbp
lea    0xef5(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Tuple_Description>:
lea    0xef9(%rip),%rax
ret

LLVM IR (-O0):
@.str = [910 x i8] c"The `Tuple` type provides a basic way to create a simple collection of objects. Its main use is the fact that it can be constructed on the stack using the `tuple` macro. This makes it suitable for a number of purposes such as use in functions that take a variable number of arguments.\0A\0ATuples can also be constructed on the heap and stored in collections. This makes them also useful as a simple _untyped_ list of objects.\0A\0AInternally Tuples are just an array of pointers terminated with a pointer to the Cello `Terminal` object. This makes positional access fast, but many other operations slow including iteration and counting the number of elements. Due to this it is only recommended Tuples are used for small collections. \0A\0ABecause Tuples are terminated with the Cello `Terminal` object this can't naturally be included within them. This object should therefore only be returned from iteration functions.\00"
define i8* @Tuple_Description() {
ret i8* getelementptr inbounds ([910 x i8], [910 x i8]* @.str, i64 0, i64 0)
}

LLVM IR (-O2):
@.str = [910 x i8] c"The `Tuple` type provides a basic way to create a simple collection of objects. Its main use is the fact that it can be constructed on the stack using the `tuple` macro. This makes it suitable for a number of purposes such as use in functions that take a variable number of arguments.\0A\0ATuples can also be constructed on the heap and stored in collections. This makes them also useful as a simple _untyped_ list of objects.\0A\0AInternally Tuples are just an array of pointers terminated with a pointer to the Cello `Terminal` object. This makes positional access fast, but many other operations slow including iteration and counting the number of elements. Due to this it is only recommended Tuples are used for small collections. \0A\0ABecause Tuples are terminated with the Cello `Terminal` object this can't naturally be included within them. This object should therefore only be returned from iteration functions.\00"
define i8* @Tuple_Description() {
ret i8* getelementptr inbounds ([910 x i8], [910 x i8]* @.str, i64 0, i64 0)
}