user: Translate the below assembly code into C programming language:

```asm
<fp_help>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  lea    D285(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  mov    $0x0,%eax
  call   <fp_version@plt>
  mov    $0x0,%eax
  call   <fp_usage@plt>
  lea    D404(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D481(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D276(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D145(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D404(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D68(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D108(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D372(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D0(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D511(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D382(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D473(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D246(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D499(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D507(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D78(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D308(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D36(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D164(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D490(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D401(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D488(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D330(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D86(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D272(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D336(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D540(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D18(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D16(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D568(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D104(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D482(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D232(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D260(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D277(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D375(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D410(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D228(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D531(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D103(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D211(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D411(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D124(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D93(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D146(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D479(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D241(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D281(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D110(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D569(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D247(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D182(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D503(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D390(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D118(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D442(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D87(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  lea    D552(%rip),%rax
  mov    %rax,%rdi
  call   <fp_msg@plt>
  mov    $0x0,%eax
  pop    %rbp
  ret
```

tool_calls: name: unpack_data
arguments: label: D285
data_type: string
name: unpack_data
arguments: label: D404
data_type: string
name: unpack_data
arguments: label: D481
data_type: string
name: unpack_data
arguments: label: D276
data_type: string
name: unpack_data
arguments: label: D145
data_type: string
name: unpack_data
arguments: label: D68
data_type: string
name: unpack_data
arguments: label: D108
data_type: string
name: unpack_data
arguments: label: D372
data_type: string
name: unpack_data
arguments: label: D0
data_type: string
name: unpack_data
arguments: label: D511
data_type: string
name: unpack_data
arguments: label: D382
data_type: string
name: unpack_data
arguments: label: D473
data_type: string
name: unpack_data
arguments: label: D246
data_type: string
name: unpack_data
arguments: label: D499
data_type: string
name: unpack_data
arguments: label: D507
data_type: string
name: unpack_data
arguments: label: D78
data_type: string
name: unpack_data
arguments: label: D308
data_type: string
name: unpack_data
arguments: label: D36
data_type: string
name: unpack_data
arguments: label: D164
data_type: string
name: unpack_data
arguments: label: D490
data_type: string
name: unpack_data
arguments: label: D401
data_type: string
name: unpack_data
arguments: label: D488
data_type: string
name: unpack_data
arguments: label: D330
data_type: string
name: unpack_data
arguments: label: D86
data_type: string
name: unpack_data
arguments: label: D272
data_type: string
name: unpack_data
arguments: label: D336
data_type: string
name: unpack_data
arguments: label: D540
data_type: string
name: unpack_data
arguments: label: D18
data_type: string
name: unpack_data
arguments: label: D16
data_type: string
name: unpack_data
arguments: label: D568
data_type: string
name: unpack_data
arguments: label: D104
data_type: string
name: unpack_data
arguments: label: D482
data_type: string
name: unpack_data
arguments: label: D232
data_type: string
name: unpack_data
arguments: label: D260
data_type: string
name: unpack_data
arguments: label: D277
data_type: string
name: unpack_data
arguments: label: D375
data_type: string
name: unpack_data
arguments: label: D410
data_type: string
name: unpack_data
arguments: label: D228
data_type: string
name: unpack_data
arguments: label: D531
data_type: string
name: unpack_data
arguments: label: D103
data_type: string
name: unpack_data
arguments: label: D211
data_type: string
name: unpack_data
arguments: label: D411
data_type: string
name: unpack_data
arguments: label: D124
data_type: string
name: unpack_data
arguments: label: D93
data_type: string
name: unpack_data
arguments: label: D146
data_type: string
name: unpack_data
arguments: label: D479
data_type: string
name: unpack_data
arguments: label: D241
data_type: string
name: unpack_data
arguments: label: D281
data_type: string
name: unpack_data
arguments: label: D110
data_type: string
name: unpack_data
arguments: label: D569
data_type: string
name: unpack_data
arguments: label: D247
data_type: string
name: unpack_data
arguments: label: D182
data_type: string
name: unpack_data
arguments: label: D503
data_type: string
name: unpack_data
arguments: label: D390
data_type: string
name: unpack_data
arguments: label: D118
data_type: string
name: unpack_data
arguments: label: D442
data_type: string
name: unpack_data
arguments: label: D87
data_type: string
name: unpack_data
arguments: label: D552
data_type: string

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

tool: D404: 


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


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


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


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


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


tool: D372:  -h          Hcompress compression, or


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


tool: D241:              


tool: D281: 
keywords shared with funpack:


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


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


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


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


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


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


tool: D118:  -H          Show this message.


tool: D442:  -V          Show version number.


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


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