user: Converte this assembly snippet into its equivalent C code:

```asm
<chaz_Floats_run>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  lea    D44(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_start_module@plt>
  lea    D138(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_append_conf@plt>
  lea    D31(%rip),%rax
  mov    %rax,%rsi
  lea    D93(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D74(%rip),%rax
  mov    %rax,%rsi
  lea    D113(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D120(%rip),%rax
  mov    %rax,%rsi
  lea    D85(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D32(%rip),%rax
  mov    %rax,%rsi
  lea    D71(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D15(%rip),%rax
  mov    %rax,%rsi
  lea    D22(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D24(%rip),%rax
  mov    %rax,%rsi
  lea    D27(%rip),%rax
  mov    %rax,%rdi
  call   <chaz_ConfWriter_add_def@plt>
  mov    $0x0,%eax
  call   <chaz_ConfWriter_end_module@plt>
  nop
  pop    %rbp
  ret
```

tool_calls: name: retrieve_data
arguments: tag: D44
type: string
name: retrieve_data
arguments: tag: D138
type: string
name: retrieve_data
arguments: tag: D31
type: string
name: retrieve_data
arguments: tag: D93
type: string
name: retrieve_data
arguments: tag: D74
type: string
name: retrieve_data
arguments: tag: D113
type: string
name: retrieve_data
arguments: tag: D120
type: string
name: retrieve_data
arguments: tag: D85
type: string
name: retrieve_data
arguments: tag: D32
type: string
name: retrieve_data
arguments: tag: D71
type: string
name: retrieve_data
arguments: tag: D15
type: string
name: retrieve_data
arguments: tag: D22
type: string
name: retrieve_data
arguments: tag: D24
type: string
name: retrieve_data
arguments: tag: D27
type: string

tool: D44: Floats

tool: D138: typedef union { unsigned char c[4]; float f; } chy_floatu32;
typedef union { unsigned char c[8]; double d; } chy_floatu64;
#ifdef CHY_BIG_END
static const chy_floatu32 chy_f32inf
    = { { 0x7F, 0x80, 0, 0 } };
static const chy_floatu32 chy_f32neginf
    = { { 0xFF, 0x80, 0, 0 } };
static const chy_floatu32 chy_f32nan
    = { { 0x7F, 0xC0, 0, 0 } };
static const chy_floatu64 chy_f64inf
    = { { 0x7F, 0xF0, 0, 0, 0, 0, 0, 0 } };
static const chy_floatu64 chy_f64neginf
    = { { 0xFF, 0xF0, 0, 0, 0, 0, 0, 0 } };
static const chy_floatu64 chy_f64nan
    = { { 0x7F, 0xF8, 0, 0, 0, 0, 0, 0 } };
#else /* BIG_END */
static const chy_floatu32 chy_f32inf
    = { { 0, 0, 0x80, 0x7F } };
static const chy_floatu32 chy_f32neginf
    = { { 0, 0, 0x80, 0xFF } };
static const chy_floatu32 chy_f32nan
    = { { 0, 0, 0xC0, 0x7F } };
static const chy_floatu64 chy_f64inf
    = { { 0, 0, 0, 0, 0, 0, 0xF0, 0x7F } };
static const chy_floatu64 chy_f64neginf
    = { { 0, 0, 0, 0, 0, 0, 0xF0, 0xFF } };
static const chy_floatu64 chy_f64nan
    = { { 0, 0, 0, 0, 0, 0, 0xF8, 0x7F } };
#endif /* BIG_END */


tool: D31: (chy_f32inf.f)

tool: D93: F32_INF

tool: D74: (chy_f32neginf.f)

tool: D113: F32_NEGINF

tool: D120: (chy_f32nan.f)

tool: D85: F32_NAN

tool: D32: (chy_f64inf.d)

tool: D71: F64_INF

tool: D15: (chy_f64neginf.d)

tool: D22: F64_NEGINF

tool: D24: (chy_f64nan.d)

tool: D27: F64_NAN

assistant: ```c
void chaz_Floats_run(void) {
  chaz_ConfWriter_start_module("Floats");
  chaz_ConfWriter_append_conf("typedef union { unsigned char c[4]; float f; } chy_floatu32;\n"
                              "typedef union { unsigned char c[8]; double d; } chy_floatu64;\n"
                              "#ifdef CHY_BIG_END\n"
                              "static const chy_floatu32 chy_f32inf\n"
                              "    = { { 0x7F, 0x80, 0, 0 } };\n"
                              "static const chy_floatu32 chy_f32neginf\n"
                              "    = { { 0xFF, 0x80, 0, 0 } };\n"
                              "static const chy_floatu32 chy_f32nan\n"
                              "    = { { 0x7F, 0xC0, 0, 0 } };\n"
                              "static const chy_floatu64 chy_f64inf\n"
                              "    = { { 0x7F, 0xF0, 0, 0, 0, 0, 0, 0 } };\n"
                              "static const chy_floatu64 chy_f64neginf\n"
                              "    = { { 0xFF, 0xF0, 0, 0, 0, 0, 0, 0 } };\n"
                              "static const chy_floatu64 chy_f64nan\n"
                              "    = { { 0x7F, 0xF8, 0, 0, 0, 0, 0, 0 } };\n"
                              "#else /* BIG_END */\n"
                              "static const chy_floatu32 chy_f32inf\n"
                              "    = { { 0, 0, 0x80, 0x7F } };\n"
                              "static const chy_floatu32 chy_f32neginf\n"
                              "    = { { 0, 0, 0x80, 0xFF } };\n"
                              "static const chy_floatu32 chy_f32nan\n"
                              "    = { { 0, 0, 0xC0, 0x7F } };\n"
                              "static const chy_floatu64 chy_f64inf\n"
                              "    = { { 0, 0, 0, 0, 0, 0, 0xF0, 0x7F } };\n"
                              "static const chy_floatu64 chy_f64neginf\n"
                              "    = { { 0, 0, 0, 0, 0, 0, 0xF0, 0xFF } };\n"
                              "static const chy_floatu64 chy_f64nan\n"
                              "    = { { 0, 0, 0, 0, 0, 0, 0xF8, 0x7F } };\n"
                              "#endif /* BIG_END */\n");
  chaz_ConfWriter_add_def("F32_INF", "(chy_f32inf.f)");
  chaz_ConfWriter_add_def("F32_NEGINF", "(chy_f32neginf.f)");
  chaz_ConfWriter_add_def("F32_NAN", "(chy_f32nan.f)");
  chaz_ConfWriter_add_def("F64_INF", "(chy_f64inf.d)");
  chaz_ConfWriter_add_def("F64_NEGINF", "(chy_f64neginf.d)");
  chaz_ConfWriter_add_def("F64_NAN", "(chy_f64nan.d)");
  chaz_ConfWriter_end_module();
}
```