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

```asm
<print_help>:
  endbr64
  push   %r12
  mov    %rdi,%rsi
  xor    %eax,%eax
  lea    D244(%rip),%rdi
  push   %rbp
  lea    D16(%rip),%rbp
  lea    D255(%rip),%r12
  sub    $0x8,%rsp
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D228(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D952(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D423(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D426(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D742(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D491(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D207(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D572(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D5(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D969(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D414(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D737(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D24(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D613(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D280(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D885(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D118(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D611(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D626(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D555(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D632(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D702(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D940(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D813(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D902(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D333(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D14(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D646(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D328(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D31(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D585(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D161(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D178(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D828(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D354(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D52(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D780(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D389(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D977(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D979(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D283(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D107(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D282(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D588(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D1012(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D82(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D182(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D551(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D810(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D968(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D377(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  lea    D304(%rip),%r12
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D233(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D565(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D7(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D264(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D803(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D299(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D706(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D628(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D146(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D343(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D970(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D361(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D101(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D924(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D124(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D373(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D931(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D983(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D515(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D653(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D714(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D798(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D512(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D995(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D213(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D398(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D95(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D967(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D789(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D474(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D17(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D668(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D494(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D615(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D287(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D884(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D160(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D679(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D92(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D481(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D690(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D121(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D134(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D670(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D617(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D688(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D470(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  xor    %eax,%eax
  add    $0x8,%rsp
  lea    D98(%rip),%rdi
  pop    %rbp
  pop    %r12
  jmp    1050 <_glp_lib_xprintf@plt>
```

tool_calls: name: unpack_data
arguments: tag: D244
type: string
name: unpack_data
arguments: tag: D16
type: string
name: unpack_data
arguments: tag: D255
type: string
name: unpack_data
arguments: tag: D228
type: string
name: unpack_data
arguments: tag: D952
type: string
name: unpack_data
arguments: tag: D423
type: string
name: unpack_data
arguments: tag: D426
type: string
name: unpack_data
arguments: tag: D742
type: string
name: unpack_data
arguments: tag: D491
type: string
name: unpack_data
arguments: tag: D207
type: string
name: unpack_data
arguments: tag: D572
type: string
name: unpack_data
arguments: tag: D5
type: string
name: unpack_data
arguments: tag: D969
type: string
name: unpack_data
arguments: tag: D414
type: string
name: unpack_data
arguments: tag: D737
type: string
name: unpack_data
arguments: tag: D24
type: string
name: unpack_data
arguments: tag: D613
type: string
name: unpack_data
arguments: tag: D280
type: string
name: unpack_data
arguments: tag: D885
type: string
name: unpack_data
arguments: tag: D118
type: string
name: unpack_data
arguments: tag: D611
type: string
name: unpack_data
arguments: tag: D626
type: string
name: unpack_data
arguments: tag: D555
type: string
name: unpack_data
arguments: tag: D632
type: string
name: unpack_data
arguments: tag: D702
type: string
name: unpack_data
arguments: tag: D940
type: string
name: unpack_data
arguments: tag: D813
type: string
name: unpack_data
arguments: tag: D902
type: string
name: unpack_data
arguments: tag: D333
type: string
name: unpack_data
arguments: tag: D14
type: string
name: unpack_data
arguments: tag: D646
type: string
name: unpack_data
arguments: tag: D328
type: string
name: unpack_data
arguments: tag: D31
type: string
name: unpack_data
arguments: tag: D585
type: string
name: unpack_data
arguments: tag: D161
type: string
name: unpack_data
arguments: tag: D178
type: string
name: unpack_data
arguments: tag: D828
type: string
name: unpack_data
arguments: tag: D354
type: string
name: unpack_data
arguments: tag: D52
type: string
name: unpack_data
arguments: tag: D780
type: string
name: unpack_data
arguments: tag: D389
type: string
name: unpack_data
arguments: tag: D977
type: string
name: unpack_data
arguments: tag: D979
type: string
name: unpack_data
arguments: tag: D283
type: string
name: unpack_data
arguments: tag: D107
type: string
name: unpack_data
arguments: tag: D282
type: string
name: unpack_data
arguments: tag: D588
type: string
name: unpack_data
arguments: tag: D1012
type: string
name: unpack_data
arguments: tag: D82
type: string
name: unpack_data
arguments: tag: D182
type: string
name: unpack_data
arguments: tag: D551
type: string
name: unpack_data
arguments: tag: D810
type: string
name: unpack_data
arguments: tag: D968
type: string
name: unpack_data
arguments: tag: D377
type: string
name: unpack_data
arguments: tag: D304
type: string
name: unpack_data
arguments: tag: D233
type: string
name: unpack_data
arguments: tag: D565
type: string
name: unpack_data
arguments: tag: D7
type: string
name: unpack_data
arguments: tag: D264
type: string
name: unpack_data
arguments: tag: D803
type: string
name: unpack_data
arguments: tag: D299
type: string
name: unpack_data
arguments: tag: D706
type: string
name: unpack_data
arguments: tag: D628
type: string
name: unpack_data
arguments: tag: D146
type: string
name: unpack_data
arguments: tag: D343
type: string
name: unpack_data
arguments: tag: D970
type: string
name: unpack_data
arguments: tag: D361
type: string
name: unpack_data
arguments: tag: D101
type: string
name: unpack_data
arguments: tag: D924
type: string
name: unpack_data
arguments: tag: D124
type: string
name: unpack_data
arguments: tag: D373
type: string
name: unpack_data
arguments: tag: D931
type: string
name: unpack_data
arguments: tag: D983
type: string
name: unpack_data
arguments: tag: D515
type: string
name: unpack_data
arguments: tag: D653
type: string
name: unpack_data
arguments: tag: D714
type: string
name: unpack_data
arguments: tag: D798
type: string
name: unpack_data
arguments: tag: D512
type: string
name: unpack_data
arguments: tag: D995
type: string
name: unpack_data
arguments: tag: D213
type: string
name: unpack_data
arguments: tag: D398
type: string
name: unpack_data
arguments: tag: D95
type: string
name: unpack_data
arguments: tag: D967
type: string
name: unpack_data
arguments: tag: D789
type: string
name: unpack_data
arguments: tag: D474
type: string
name: unpack_data
arguments: tag: D17
type: string
name: unpack_data
arguments: tag: D668
type: string
name: unpack_data
arguments: tag: D494
type: string
name: unpack_data
arguments: tag: D615
type: string
name: unpack_data
arguments: tag: D287
type: string
name: unpack_data
arguments: tag: D884
type: string
name: unpack_data
arguments: tag: D160
type: string
name: unpack_data
arguments: tag: D679
type: string
name: unpack_data
arguments: tag: D92
type: string
name: unpack_data
arguments: tag: D481
type: string
name: unpack_data
arguments: tag: D690
type: string
name: unpack_data
arguments: tag: D121
type: string
name: unpack_data
arguments: tag: D134
type: string
name: unpack_data
arguments: tag: D670
type: string
name: unpack_data
arguments: tag: D617
type: string
name: unpack_data
arguments: tag: D688
type: string
name: unpack_data
arguments: tag: D470
type: string
name: unpack_data
arguments: tag: D98
type: string

tool: D244: Usage: %s [options...] filename


tool: D16: 


tool: D255:                      (slower, more stable)


tool: D228: General options:


tool: D952:    --mps             read LP/MIP problem in fixed MPS format


tool: D423:    --freemps         read LP/MIP problem in free MPS format (default)


tool: D426:    --cpxlp           read LP/MIP problem in CPLEX LP format


tool: D742:    --math            read LP/MIP model written in GNU MathProg modeling


tool: D491:                      language


tool: D207:    -m filename, --model filename


tool: D572:                      read model section and optional data section from


tool: D5:                      filename (the same as --math)


tool: D969:    -d filename, --data filename


tool: D414:                      read data section from filename (for --math only);


tool: D737:                      if model file also has data section, it is ignored


tool: D24:    -y filename, --display filename


tool: D613:                      send display output to filename (for --math only);


tool: D280:                      by default the output is sent to terminal


tool: D885:    --mincost         read min-cost flow problem in DIMACS format


tool: D118:    --maxflow         read maximum flow problem in DIMACS format


tool: D611:    --simplex         use simplex method (default)


tool: D626:    --interior        use interior point method (LP only)


tool: D555:    -r filename, --read filename


tool: D632:                      read solution from filename rather to find it with


tool: D702:                      the solver


tool: D940:    --min             minimization


tool: D813:    --max             maximization


tool: D902:    --scale           scale problem (default)


tool: D333:    --noscale         do not scale problem


tool: D14:    -o filename, --output filename


tool: D646:                      write solution to filename in printable format


tool: D328:    -w filename, --write filename


tool: D31:                      write solution to filename in plain text format


tool: D585:    --bounds filename


tool: D161:                      write sensitivity bounds to filename in printable


tool: D178:                      format (LP only)


tool: D828:    --tmlim nnn       limit solution time to nnn seconds 


tool: D354:    --memlim nnn      limit available memory to nnn megabytes


tool: D52:    --check           do not solve problem, check input data only


tool: D780:    --name probname   change problem name to probname


tool: D389:    --wmps filename   write problem to filename in fixed MPS format


tool: D977:    --wfreemps filename


tool: D979:                      write problem to filename in free MPS format


tool: D283:    --wcpxlp filename write problem to filename in CPLEX LP format


tool: D107:    --wpb filename    write problem to filename in OPB format


tool: D282:    --wnpb filename   write problem to filename in normalized OPB format


tool: D588:    --log filename    write copy of terminal output to filename


tool: D1012:    -h, --help        display this help information and exit


tool: D82:    -v, --version     display program version and exit


tool: D182: LP basis factorization options:


tool: D551:    --luf             LU + Forrest-Tomlin update


tool: D810:                      (faster, less stable; default)


tool: D968:    --cbg             LU + Schur complement + Bartels-Golub update


tool: D377:    --cgr             LU + Schur complement + Givens rotation update


tool: D304:                      (default)


tool: D233: Options specific to simplex solver:


tool: D565:    --primal          use primal simplex (default)


tool: D7:    --dual            use dual simplex


tool: D264:    --std             use standard initial basis of all slacks


tool: D803:    --adv             use advanced initial basis (default)


tool: D299:    --bib             use Bixby's initial basis


tool: D706:    --steep           use steepest edge technique (default)


tool: D628:    --nosteep         use standard "textbook" pricing


tool: D146:    --relax           use Harris' two-pass ratio test (default)


tool: D343:    --norelax         use standard "textbook" ratio test


tool: D970:    --presol          use presolver (default; assumes --scale and --adv)


tool: D361:    --nopresol        do not use presolver


tool: D101:    --exact           use simplex method based on exact arithmetic


tool: D924:    --xcheck          check final basis using exact arithmetic


tool: D124: Options specific to interior-point solver:


tool: D373:    --nord            use natural (original) ordering


tool: D931:    --qmd             use quotient minimum degree ordering


tool: D983:    --amd             use approximate minimum degree ordering (default)


tool: D515:    --symamd          use approximate minimum degree ordering


tool: D653: Options specific to MIP solver:


tool: D714:    --nomip           consider all integer variables as continuous


tool: D798:                      (allows solving MIP as pure LP)


tool: D512:    --first           branch on first integer variable


tool: D995:    --last            branch on last integer variable


tool: D213:    --mostf           branch on most fractional variable 


tool: D398:    --drtom           branch using heuristic by Driebeck and Tomlin


tool: D95:    --pcost           branch using hybrid pseudocost heuristic (may be


tool: D967:                      useful for hard instances)


tool: D789:    --dfs             backtrack using depth first search 


tool: D474:    --bfs             backtrack using breadth first search


tool: D17:    --bestp           backtrack using the best projection heuristic


tool: D668:    --bestb           backtrack using node with best local bound


tool: D494:    --intopt          use MIP presolver (default)


tool: D615:    --nointopt        do not use MIP presolver


tool: D287:    --binarize        replace general integer variables by binary ones


tool: D884:                      (assumes --intopt)


tool: D160:    --fpump           apply feasibility pump heuristic


tool: D679:    --gomory          generate Gomory's mixed integer cuts


tool: D92:    --mir             generate MIR (mixed integer rounding) cuts


tool: D481:    --cover           generate mixed cover cuts


tool: D690:    --clique          generate clique cuts


tool: D121:    --cuts            generate all cuts above


tool: D134:    --mipgap tol      set relative mip gap tolerance to tol


tool: D670: For description of the MPS and CPLEX LP formats see Reference Manual.


tool: D617: For description of the modeling language see "GLPK: Modeling Language


tool: D688: GNU MathProg". Both documents are included in the GLPK distribution.


tool: D470: See GLPK web page at <http://www.gnu.org/software/glpk/glpk.html>.


tool: D98: Please report bugs to <bug-glpk@gnu.org>.


assistant: ```c
void print_help(const char *my_name) {
  _glp_lib_xprintf("Usage: %s [options...] filename\n", my_name);
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("General options:\n");
  _glp_lib_xprintf("   --mps             read LP/MIP problem in fixed MPS fo"
                   "rmat\n");
  _glp_lib_xprintf("   --freemps         read LP/MIP problem in free MPS for"
                   "mat (default)\n");
  _glp_lib_xprintf("   --cpxlp           read LP/MIP problem in CPLEX LP for"
                   "mat\n");
  _glp_lib_xprintf("   --math            read LP/MIP model written in GNU Ma"
                   "thProg modeling\n");
  _glp_lib_xprintf("                     language\n");
  _glp_lib_xprintf("   -m filename, --model filename\n");
  _glp_lib_xprintf("                     read model section and optional dat"
                   "a section from\n");
  _glp_lib_xprintf("                     filename (the same as --math)\n");
  _glp_lib_xprintf("   -d filename, --data filename\n");
  _glp_lib_xprintf("                     read data section from filename (fo"
                   "r --math only);\n");
  _glp_lib_xprintf("                     if model file also has data section"
                   ", it is ignored\n");
  _glp_lib_xprintf("   -y filename, --display filename\n");
  _glp_lib_xprintf("                     send display output to filename (fo"
                   "r --math only);\n");
  _glp_lib_xprintf("                     by default the output is sent to te"
                   "rminal\n");
  _glp_lib_xprintf("   --mincost         read min-cost flow problem in DIMAC"
                   "S format\n");
  _glp_lib_xprintf("   --maxflow         read maximum flow problem in DIMACS"
                   " format\n");
  _glp_lib_xprintf("   --simplex         use simplex method (default)\n");
  _glp_lib_xprintf("   --interior        use interior point method (LP only)"
                   "\n");
  _glp_lib_xprintf("   -r filename, --read filename\n");
  _glp_lib_xprintf("                     read solution from filename rather "
                   "to find it with\n");
  _glp_lib_xprintf("                     the solver\n");
  _glp_lib_xprintf("   --min             minimization\n");
  _glp_lib_xprintf("   --max             maximization\n");
  _glp_lib_xprintf("   --scale           scale problem (default)\n");
  _glp_lib_xprintf("   --noscale         do not scale problem\n");
  _glp_lib_xprintf("   -o filename, --output filename\n");
  _glp_lib_xprintf("                     write solution to filename in print"
                   "able format\n");
  _glp_lib_xprintf("   -w filename, --write filename\n");
  _glp_lib_xprintf("                     write solution to filename in plain"
                   " text format\n");
  _glp_lib_xprintf("   --bounds filename\n");
  _glp_lib_xprintf("                     write sensitivity bounds to filenam"
                   "e in printable\n");
  _glp_lib_xprintf("                     format (LP only)\n");
  _glp_lib_xprintf("   --tmlim nnn       limit solution time to nnn seconds "
                   "\n");
  _glp_lib_xprintf("   --memlim nnn      limit available memory to nnn megab"
                   "ytes\n");
  _glp_lib_xprintf("   --check           do not solve problem, check input d"
                   "ata only\n");
  _glp_lib_xprintf("   --name probname   change problem name to probname\n");
  _glp_lib_xprintf("   --wmps filename   write problem to filename in fixed "
                   "MPS format\n");
  _glp_lib_xprintf("   --wfreemps filename\n");
  _glp_lib_xprintf("                     write problem to filename in free M"
                   "PS format\n");
  _glp_lib_xprintf("   --wcpxlp filename write problem to filename in CPLEX "
                   "LP format\n");
  _glp_lib_xprintf("   --wpb filename    write problem to filename in OPB fo"
                   "rmat\n");
  _glp_lib_xprintf("   --wnpb filename   write problem to filename in normal"
                   "ized OPB format\n");
  _glp_lib_xprintf("   --log filename    write copy of terminal output to fi"
                   "lename\n");
  _glp_lib_xprintf("   -h, --help        display this help information and e"
                   "xit\n");
  _glp_lib_xprintf("   -v, --version     display program version and exit\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("LP basis factorization options:\n");
  _glp_lib_xprintf("   --luf             LU + Forrest-Tomlin update\n");
  _glp_lib_xprintf("                     (faster, less stable; default)\n");
  _glp_lib_xprintf("   --cbg             LU + Schur complement + Bartels-Gol"
                   "ub update\n");
  _glp_lib_xprintf("                     (slower, more stable)\n");
  _glp_lib_xprintf("   --cgr             LU + Schur complement + Givens rota"
                   "tion update\n");
  _glp_lib_xprintf("                     (slower, more stable)\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("Options specific to simplex solver:\n");
  _glp_lib_xprintf("   --primal          use primal simplex (default)\n");
  _glp_lib_xprintf("   --dual            use dual simplex\n");
  _glp_lib_xprintf("   --std             use standard initial basis of all s"
                   "lacks\n");
  _glp_lib_xprintf("   --adv             use advanced initial basis (default"
                   ")\n");
  _glp_lib_xprintf("   --bib             use Bixby's initial basis\n");
  _glp_lib_xprintf("   --steep           use steepest edge technique (defaul"
                   "t)\n");
  _glp_lib_xprintf("   --nosteep         use standard \"textbook\" pricing\n");
  _glp_lib_xprintf("   --relax           use Harris' two-pass ratio test (de"
                   "fault)\n");
  _glp_lib_xprintf("   --norelax         use standard \"textbook\" ratio tes"
                   "t\n");
  _glp_lib_xprintf("   --presol          use presolver (default; assumes --s"
                   "cale and --adv)\n");
  _glp_lib_xprintf("   --nopresol        do not use presolver\n");
  _glp_lib_xprintf("   --exact           use simplex method based on exact a"
                   "rithmetic\n");
  _glp_lib_xprintf("   --xcheck          check final basis using exact arith"
                   "metic\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("Options specific to interior-point solver:\n");
  _glp_lib_xprintf("   --nord            use natural (original) ordering\n");
  _glp_lib_xprintf("   --qmd             use quotient minimum degree orderin"
                   "g\n");
  _glp_lib_xprintf("   --amd             use approximate minimum degree orde"
                   "ring (default)\n");
  _glp_lib_xprintf("   --symamd          use approximate minimum degree orde"
                   "ring\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("Options specific to MIP solver:\n");
  _glp_lib_xprintf("   --nomip           consider all integer variables as c"
                   "ontinuous\n");
  _glp_lib_xprintf("                     (allows solving MIP as pure LP)\n");
  _glp_lib_xprintf("   --first           branch on first integer variable\n");
  _glp_lib_xprintf("   --last            branch on last integer variable\n");
  _glp_lib_xprintf("   --mostf           branch on most fractional variable "
                   "\n");
  _glp_lib_xprintf("   --drtom           branch using heuristic by Driebeck "
                   "and Tomlin\n");
  _glp_lib_xprintf("                     (default)\n");
  _glp_lib_xprintf("   --pcost           branch using hybrid pseudocost heur"
                   "istic (may be\n");
  _glp_lib_xprintf("                     useful for hard instances)\n");
  _glp_lib_xprintf("   --dfs             backtrack using depth first search "
                   "\n");
  _glp_lib_xprintf("   --bfs             backtrack using breadth first searc"
                   "h\n");
  _glp_lib_xprintf("   --bestp           backtrack using the best projection"
                   " heuristic\n");
  _glp_lib_xprintf("   --bestb           backtrack using node with best loca"
                   "l bound\n");
  _glp_lib_xprintf("                     (default)\n");
  _glp_lib_xprintf("   --intopt          use MIP presolver (default)\n");
  _glp_lib_xprintf("   --nointopt        do not use MIP presolver\n");
  _glp_lib_xprintf("   --binarize        replace general integer variables b"
                   "y binary ones\n");
  _glp_lib_xprintf("                     (assumes --intopt)\n");
  _glp_lib_xprintf("   --fpump           apply feasibility pump heuristic\n");
  _glp_lib_xprintf("   --gomory          generate Gomory's mixed integer cut"
                   "s\n");
  _glp_lib_xprintf("   --mir             generate MIR (mixed integer roundin"
                   "g) cuts\n");
  _glp_lib_xprintf("   --cover           generate mixed cover cuts\n");
  _glp_lib_xprintf("   --clique          generate clique cuts\n");
  _glp_lib_xprintf("   --cuts            generate all cuts above\n");
  _glp_lib_xprintf("   --mipgap tol      set relative mip gap tolerance to t"
                   "ol\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("For description of the MPS and CPLEX LP formats see Refe"
                   "rence Manual.\n");
  _glp_lib_xprintf("For description of the modeling language see \"GLPK: Mod"
                   "eling Language\n");
  _glp_lib_xprintf("GNU MathProg\". Both documents are included in the GLPK "
                   "distribution.\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("See GLPK web page at <http://www.gnu.org/software/glpk/g"
                   "lpk.html>.\n");
  _glp_lib_xprintf("\n");
  _glp_lib_xprintf("Please report bugs to <bug-glpk@gnu.org>.\n");
  return;
}
```