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

```asm
<chaz_Floats_run>:
  endbr64
  sub    $0x8,%rsp
  lea    D9(%rip),%rdi
  call   <chaz_ConfWriter_start_module@plt>
  lea    D125(%rip),%rdi
  call   <chaz_ConfWriter_append_conf@plt>
  lea    D136(%rip),%rsi
  lea    D3(%rip),%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D24(%rip),%rsi
  lea    D116(%rip),%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D30(%rip),%rsi
  lea    D77(%rip),%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D68(%rip),%rsi
  lea    D98(%rip),%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D11(%rip),%rsi
  lea    D42(%rip),%rdi
  call   <chaz_ConfWriter_add_def@plt>
  lea    D41(%rip),%rsi
  lea    D88(%rip),%rdi
  call   <chaz_ConfWriter_add_def@plt>
  xor    %eax,%eax
  add    $0x8,%rsp
  jmp    1090 <chaz_ConfWriter_end_module@plt>
```

tool_calls: name: parse_data
arguments: data_tag: D9
type_guessed: string
name: parse_data
arguments: data_tag: D125
type_guessed: string
name: parse_data
arguments: data_tag: D136
type_guessed: string
name: parse_data
arguments: data_tag: D3
type_guessed: string
name: parse_data
arguments: data_tag: D24
type_guessed: string
name: parse_data
arguments: data_tag: D116
type_guessed: string
name: parse_data
arguments: data_tag: D30
type_guessed: string
name: parse_data
arguments: data_tag: D77
type_guessed: string
name: parse_data
arguments: data_tag: D68
type_guessed: string
name: parse_data
arguments: data_tag: D98
type_guessed: string
name: parse_data
arguments: data_tag: D11
type_guessed: string
name: parse_data
arguments: data_tag: D42
type_guessed: string
name: parse_data
arguments: data_tag: D41
type_guessed: string
name: parse_data
arguments: data_tag: D88
type_guessed: string

tool: D9: Floats

tool: D125: 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: D136: (chy_f32inf.f)

tool: D3: F32_INF

tool: D24: (chy_f32neginf.f)

tool: D116: F32_NEGINF

tool: D30: (chy_f32nan.f)

tool: D77: F32_NAN

tool: D68: (chy_f64inf.d)

tool: D98: F64_INF

tool: D11: (chy_f64neginf.d)

tool: D42: F64_NEGINF

tool: D41: (chy_f64nan.d)

tool: D88: 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();
}
```