user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<fp_help>:
  endbr64
  push   %rbp
  lea    D291(%rip),%rdi
  lea    D250(%rip),%rbp
  call   <fp_msg@plt>
  xor    %eax,%eax
  call   <fp_version@plt>
  xor    %eax,%eax
  call   <fp_usage@plt>
  mov    %rbp,%rdi
  call   <fp_msg@plt>
  lea    D234(%rip),%rdi
  call   <fp_msg@plt>
  lea    D208(%rip),%rdi
  call   <fp_msg@plt>
  lea    D315(%rip),%rdi
  call   <fp_msg@plt>
  mov    %rbp,%rdi
  call   <fp_msg@plt>
  lea    D177(%rip),%rdi
  call   <fp_msg@plt>
  lea    D488(%rip),%rdi
  call   <fp_msg@plt>
  lea    D79(%rip),%rdi
  call   <fp_msg@plt>
  lea    D245(%rip),%rdi
  call   <fp_msg@plt>
  lea    D358(%rip),%rdi
  call   <fp_msg@plt>
  lea    D388(%rip),%rdi
  call   <fp_msg@plt>
  lea    D392(%rip),%rdi
  call   <fp_msg@plt>
  lea    D223(%rip),%rdi
  call   <fp_msg@plt>
  lea    D125(%rip),%rdi
  call   <fp_msg@plt>
  lea    D40(%rip),%rdi
  call   <fp_msg@plt>
  lea    D153(%rip),%rdi
  call   <fp_msg@plt>
  lea    D217(%rip),%rdi
  call   <fp_msg@plt>
  lea    D49(%rip),%rdi
  call   <fp_msg@plt>
  lea    D213(%rip),%rdi
  call   <fp_msg@plt>
  lea    D425(%rip),%rdi
  call   <fp_msg@plt>
  lea    D445(%rip),%rdi
  call   <fp_msg@plt>
  lea    D413(%rip),%rdi
  call   <fp_msg@plt>
  lea    D380(%rip),%rdi
  call   <fp_msg@plt>
  lea    D386(%rip),%rdi
  call   <fp_msg@plt>
  lea    D532(%rip),%rdi
  call   <fp_msg@plt>
  lea    D408(%rip),%rdi
  call   <fp_msg@plt>
  lea    D81(%rip),%rdi
  call   <fp_msg@plt>
  lea    D546(%rip),%rdi
  call   <fp_msg@plt>
  lea    D352(%rip),%rdi
  call   <fp_msg@plt>
  lea    D167(%rip),%rdi
  call   <fp_msg@plt>
  lea    D270(%rip),%rdi
  call   <fp_msg@plt>
  lea    D379(%rip),%rdi
  call   <fp_msg@plt>
  lea    D136(%rip),%rdi
  call   <fp_msg@plt>
  lea    D101(%rip),%rdi
  call   <fp_msg@plt>
  lea    D57(%rip),%rdi
  call   <fp_msg@plt>
  lea    D122(%rip),%rdi
  call   <fp_msg@plt>
  lea    D225(%rip),%rdi
  call   <fp_msg@plt>
  lea    D146(%rip),%rdi
  call   <fp_msg@plt>
  lea    D197(%rip),%rdi
  call   <fp_msg@plt>
  lea    D148(%rip),%rdi
  call   <fp_msg@plt>
  lea    D444(%rip),%rdi
  call   <fp_msg@plt>
  lea    D482(%rip),%rdi
  call   <fp_msg@plt>
  lea    D434(%rip),%rdi
  call   <fp_msg@plt>
  lea    D277(%rip),%rdi
  call   <fp_msg@plt>
  lea    D296(%rip),%rdi
  call   <fp_msg@plt>
  lea    D91(%rip),%rdi
  call   <fp_msg@plt>
  lea    D62(%rip),%rdi
  call   <fp_msg@plt>
  lea    D549(%rip),%rdi
  call   <fp_msg@plt>
  lea    D9(%rip),%rdi
  call   <fp_msg@plt>
  lea    D287(%rip),%rdi
  call   <fp_msg@plt>
  lea    D447(%rip),%rdi
  call   <fp_msg@plt>
  lea    D191(%rip),%rdi
  call   <fp_msg@plt>
  lea    D531(%rip),%rdi
  call   <fp_msg@plt>
  lea    D353(%rip),%rdi
  call   <fp_msg@plt>
  lea    D492(%rip),%rdi
  call   <fp_msg@plt>
  lea    D419(%rip),%rdi
  call   <fp_msg@plt>
  lea    D63(%rip),%rdi
  call   <fp_msg@plt>
  lea    D289(%rip),%rdi
  call   <fp_msg@plt>
  xor    %eax,%eax
  pop    %rbp
  ret
```

tool_calls: name: extract_symbolic_data
arguments: data_label: D291
type_infered: string
name: extract_symbolic_data
arguments: data_label: D250
type_infered: string
name: extract_symbolic_data
arguments: data_label: D234
type_infered: string
name: extract_symbolic_data
arguments: data_label: D208
type_infered: string
name: extract_symbolic_data
arguments: data_label: D315
type_infered: string
name: extract_symbolic_data
arguments: data_label: D177
type_infered: string
name: extract_symbolic_data
arguments: data_label: D488
type_infered: string
name: extract_symbolic_data
arguments: data_label: D79
type_infered: string
name: extract_symbolic_data
arguments: data_label: D245
type_infered: string
name: extract_symbolic_data
arguments: data_label: D358
type_infered: string
name: extract_symbolic_data
arguments: data_label: D388
type_infered: string
name: extract_symbolic_data
arguments: data_label: D392
type_infered: string
name: extract_symbolic_data
arguments: data_label: D223
type_infered: string
name: extract_symbolic_data
arguments: data_label: D125
type_infered: string
name: extract_symbolic_data
arguments: data_label: D40
type_infered: string
name: extract_symbolic_data
arguments: data_label: D153
type_infered: string
name: extract_symbolic_data
arguments: data_label: D217
type_infered: string
name: extract_symbolic_data
arguments: data_label: D49
type_infered: string
name: extract_symbolic_data
arguments: data_label: D213
type_infered: string
name: extract_symbolic_data
arguments: data_label: D425
type_infered: string
name: extract_symbolic_data
arguments: data_label: D445
type_infered: string
name: extract_symbolic_data
arguments: data_label: D413
type_infered: string
name: extract_symbolic_data
arguments: data_label: D380
type_infered: string
name: extract_symbolic_data
arguments: data_label: D386
type_infered: string
name: extract_symbolic_data
arguments: data_label: D532
type_infered: string
name: extract_symbolic_data
arguments: data_label: D408
type_infered: string
name: extract_symbolic_data
arguments: data_label: D81
type_infered: string
name: extract_symbolic_data
arguments: data_label: D546
type_infered: string
name: extract_symbolic_data
arguments: data_label: D352
type_infered: string
name: extract_symbolic_data
arguments: data_label: D167
type_infered: string
name: extract_symbolic_data
arguments: data_label: D270
type_infered: string
name: extract_symbolic_data
arguments: data_label: D379
type_infered: string
name: extract_symbolic_data
arguments: data_label: D136
type_infered: string
name: extract_symbolic_data
arguments: data_label: D101
type_infered: string
name: extract_symbolic_data
arguments: data_label: D57
type_infered: string
name: extract_symbolic_data
arguments: data_label: D122
type_infered: string
name: extract_symbolic_data
arguments: data_label: D225
type_infered: string
name: extract_symbolic_data
arguments: data_label: D146
type_infered: string
name: extract_symbolic_data
arguments: data_label: D197
type_infered: string
name: extract_symbolic_data
arguments: data_label: D148
type_infered: string
name: extract_symbolic_data
arguments: data_label: D444
type_infered: string
name: extract_symbolic_data
arguments: data_label: D482
type_infered: string
name: extract_symbolic_data
arguments: data_label: D434
type_infered: string
name: extract_symbolic_data
arguments: data_label: D277
type_infered: string
name: extract_symbolic_data
arguments: data_label: D296
type_infered: string
name: extract_symbolic_data
arguments: data_label: D91
type_infered: string
name: extract_symbolic_data
arguments: data_label: D62
type_infered: string
name: extract_symbolic_data
arguments: data_label: D549
type_infered: string
name: extract_symbolic_data
arguments: data_label: D9
type_infered: string
name: extract_symbolic_data
arguments: data_label: D287
type_infered: string
name: extract_symbolic_data
arguments: data_label: D447
type_infered: string
name: extract_symbolic_data
arguments: data_label: D191
type_infered: string
name: extract_symbolic_data
arguments: data_label: D531
type_infered: string
name: extract_symbolic_data
arguments: data_label: D353
type_infered: string
name: extract_symbolic_data
arguments: data_label: D492
type_infered: string
name: extract_symbolic_data
arguments: data_label: D419
type_infered: string
name: extract_symbolic_data
arguments: data_label: D63
type_infered: string
name: extract_symbolic_data
arguments: data_label: D289
type_infered: string

tool: D291: fpack, a FITS image compression program.  Version 

tool: D250: 


tool: D234: NOTE: the compression parameters specified on the fpack command line may


tool: D208: be over-ridden by compression directive keywords in the header of each HDU


tool: D315: of the input file(s). See the fpack User's Guide for more details


tool: D177: Flags must be separate and appear before filenames:


tool: D488:  -r          Rice compression [default], or


tool: D79:  -h          Hcompress compression, or


tool: D245:  -g  or -g1  GZIP_1 (per-tile) compression, or


tool: D358:  -g2         GZIP_2 (per-tile) compression (with byte shuffling), or


tool: D388:  -p          PLIO compression (only for positive 8 or 16-bit integer images).


tool: D392:  -d          Tile the image without compression (debugging mode).


tool: D223:  -w          Compress the whole image as a single large tile.


tool: D125:  -t <axes>   Comma separated list of tile dimensions [default is row by row].


tool: D40:  -q <level>  Quantized level spacing when converting floating point images to


tool: D153:              scaled integers. (+value relative to sigma of background noise;


tool: D217:              -value is absolute). Default q value of 4 gives a compression ratio


tool: D49:              of about 6 with very high fidelity (only 0.26% increase in noise).


tool: D213:              Using q values of  2, or 1 will give compression ratios of


tool: D425:              about 8, or 10, respectively (with 1.0% or 4.1% noise increase).


tool: D445:              The scaled quantized values are randomly dithered using a seed 


tool: D413:              value determined from the system clock at run time.


tool: D380:              Use -q0 instead of -q to suppress random dithering.


tool: D386:              Use -qz instead of -q to not dither zero-valued pixels.


tool: D532:              Use -qt or -qzt to compute random dithering seed from first tile checksum.


tool: D408:              Use -qN or -qzN, (N in range 1 to 10000) to use a specific dithering seed.


tool: D81:              Floating-point images can be losslessly compressed by selecting


tool: D546:              the GZIP algorithm and specifying -q 0, but this is slower and often


tool: D352:              produces much less compression than the default quantization method.


tool: D167:  -i2f        Convert integer images to floating point, then quantize and compress


tool: D270:              using the specified q level.  When used appropriately, this lossy


tool: D379:              compression method can give much better compression than the normal


tool: D136:              lossless compression methods without significant loss of information.


tool: D101:              The -n3ratio and -n3min flags control the minimum noise thresholds;


tool: D57:              Images below these thresholds will be losslessly compressed.


tool: D122:  -n3ratio    Minimum ratio of background noise sigma divided by q.  Default = 2.0.


tool: D225:  -n3min      Minimum background noise sigma. Default = 6. The -i2f flag will be ignored


tool: D146:              if the noise level in the image does not exceed both thresholds.


tool: D197:  -s <scale>  Scale factor for lossy Hcompress [default = 0 = lossless]


tool: D148:              (+values relative to RMS noise; -value is absolute)


tool: D444:  -n <noise>  Rescale scaled-integer images to reduce noise and improve compression.


tool: D482:  -v          Verbose mode; list each file as it is processed.


tool: D434:  -T          Show compression algorithm comparison test statistics; files unchanged.


tool: D277:  -R <file>   Write the comparison test report (above) to a text file.


tool: D296:  -table      Compress FITS binary tables as well as compress any image HDUs.


tool: D91:  -tableonly  Compress only FITS binary tables; do not compress any image HDUs.


tool: D62:              


tool: D549: 
keywords shared with funpack:


tool: D9:  -F          Overwrite input file by output file with same name.


tool: D287:  -D          Delete input file after writing output.


tool: D447:  -Y          Suppress prompts to confirm -F or -D options.


tool: D191:  -S          Output compressed FITS files to STDOUT.


tool: D531:  -L          List contents; files unchanged.


tool: D353:  -C          Don't update FITS checksum keywords.


tool: D492:  -H          Show this message.


tool: D419:  -V          Show version number.


tool: D63: 
 <FITS>      FITS files to pack; enter '-' (a hyphen) to read input from stdin stream.


tool: D289:  Refer to the fpack User's Guide for more extensive help.


assistant: ```c
int fp_help(void) {
  fp_msg("fpack, a FITS image compression program.  Version ");
  fp_version();
  fp_usage();
  fp_msg("\n");
  fp_msg("NOTE: the compression parameters specified on the fpack command line may\n");
  fp_msg("be over-ridden by compression directive keywords in the header of each HDU\n");
  fp_msg("of the input file(s). See the fpack User's Guide for more details\n");
  fp_msg("\n");
  fp_msg("Flags must be separate and appear before filenames:\n");
  fp_msg(" -r          Rice compression [default], or\n");
  fp_msg(" -h          Hcompress compression, or\n");
  fp_msg(" -g  or -g1  GZIP_1 (per-tile) compression, or\n");
  fp_msg(" -g2         GZIP_2 (per-tile) compression (with byte shuffling), or\n");
  fp_msg(" -p          PLIO compression (only for positive 8 or 16-bit integer images).\n");
  fp_msg(" -d          Tile the image without compression (debugging mode).\n");
  fp_msg(" -w          Compress the whole image as a single large tile.\n");
  fp_msg(" -t <axes>   Comma separated list of tile dimensions [default is row by row].\n");
  fp_msg(" -q <level>  Quantized level spacing when converting floating point images to\n");
  fp_msg("             scaled integers. (+value relative to sigma of background noise;\n");
  fp_msg("             -value is absolute). Default q value of 4 gives a compression ratio\n");
  fp_msg("             of about 6 with very high fidelity (only 0.26% increase in noise).\n");
  fp_msg("             Using q values of  2, or 1 will give compression ratios of\n");
  fp_msg("             about 8, or 10, respectively (with 1.0% or 4.1% noise increase).\n");
  fp_msg("             The scaled quantized values are randomly dithered using a seed \n");
  fp_msg("             value determined from the system clock at run time.\n");
  fp_msg("             Use -q0 instead of -q to suppress random dithering.\n");
  fp_msg("             Use -qz instead of -q to not dither zero-valued pixels.\n");
  fp_msg("             Use -qt or -qzt to compute random dithering seed from first tile checksum.\n");
  fp_msg("             Use -qN or -qzN, (N in range 1 to 10000) to use a specific dithering seed.\n");
  fp_msg("             Floating-point images can be losslessly compressed by selecting\n");
  fp_msg("             the GZIP algorithm and specifying -q 0, but this is slower and often\n");
  fp_msg("             produces much less compression than the default quantization method.\n");
  fp_msg(" -i2f        Convert integer images to floating point, then quantize and compress\n");
  fp_msg("             using the specified q level.  When used appropriately, this lossy\n");
  fp_msg("             compression method can give much better compression than the normal\n");
  fp_msg("             lossless compression methods without significant loss of information.\n");
  fp_msg("             The -n3ratio and -n3min flags control the minimum noise thresholds;\n");
  fp_msg("             Images below these thresholds will be losslessly compressed.\n");
  fp_msg(" -n3ratio    Minimum ratio of background noise sigma divided by q.  Default = 2.0.\n");
  fp_msg(" -n3min      Minimum background noise sigma. Default = 6. The -i2f flag will be ignored\n");
  fp_msg("             if the noise level in the image does not exceed both thresholds.\n");
  fp_msg(" -s <scale>  Scale factor for lossy Hcompress [default = 0 = lossless]\n");
  fp_msg("             (+values relative to RMS noise; -value is absolute)\n");
  fp_msg(" -n <noise>  Rescale scaled-integer images to reduce noise and improve compression.\n");
  fp_msg(" -v          Verbose mode; list each file as it is processed.\n");
  fp_msg(" -T          Show compression algorithm comparison test statistics; files unchanged.\n");
  fp_msg(" -R <file>   Write the comparison test report (above) to a text file.\n");
  fp_msg(" -table      Compress FITS binary tables as well as compress any image HDUs.\n");
  fp_msg(" -tableonly  Compress only FITS binary tables; do not compress any image HDUs.\n");
  fp_msg("             \n");
  fp_msg("\nkeywords shared with funpack:\n");
  fp_msg(" -F          Overwrite input file by output file with same name.\n");
  fp_msg(" -D          Delete input file after writing output.\n");
  fp_msg(" -Y          Suppress prompts to confirm -F or -D options.\n");
  fp_msg(" -S          Output compressed FITS files to STDOUT.\n");
  fp_msg(" -L          List contents; files unchanged.\n");
  fp_msg(" -C          Don't update FITS checksum keywords.\n");
  fp_msg(" -H          Show this message.\n");
  fp_msg(" -V          Show version number.\n");
  fp_msg("\n <FITS>      FITS files to pack; enter '-' (a hyphen) to read input from stdin stream.\n");
  fp_msg(" Refer to the fpack User's Guide for more extensive help.\n");
  return (0);
}
```