user: Demonstrate the C code that generates the assembly output below:

```asm
<print_help>:
  endbr64
  push   %r12
  mov    %rdi,%rsi
  xor    %eax,%eax
  lea    D446(%rip),%rdi
  push   %rbp
  lea    D990(%rip),%rbp
  lea    D387(%rip),%r12
  sub    $0x8,%rsp
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D4(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D769(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D673(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D588(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D549(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D108(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D850(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D742(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D506(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D105(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D341(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D70(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D867(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D832(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D682(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D37(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D478(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D214(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D3(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D126(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D215(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D1(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D988(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D140(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D668(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D898(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D322(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D208(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D981(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D287(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D209(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D279(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D922(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D172(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D412(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D377(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D391(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D62(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D405(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D901(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D714(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D388(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D73(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D702(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D100(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D183(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D890(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D175(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D836(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D574(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D852(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  lea    D373(%rip),%r12
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D1004(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D834(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D891(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D144(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D103(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D697(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D40(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D260(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D687(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D229(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D970(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D691(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D197(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D228(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D779(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D739(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D871(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D853(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D754(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D284(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D810(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D553(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D954(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D1002(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D598(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D132(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D653(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D297(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D35(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D752(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D566(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D761(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D1017(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D937(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D2(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D457(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D632(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D828(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D16(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D81(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D605(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D23(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D926(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D398(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D600(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D1023(%rip),%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <_glp_lib_xprintf@plt>
  lea    D949(%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    D429(%rip),%rdi
  pop    %rbp
  pop    %r12
  jmp    1050 <_glp_lib_xprintf@plt>
```

tool_calls: name: retrieve_data
arguments: label: D446
type_infered: string
name: retrieve_data
arguments: label: D990
type_infered: string
name: retrieve_data
arguments: label: D387
type_infered: string
name: retrieve_data
arguments: label: D4
type_infered: string
name: retrieve_data
arguments: label: D769
type_infered: string
name: retrieve_data
arguments: label: D673
type_infered: string
name: retrieve_data
arguments: label: D588
type_infered: string
name: retrieve_data
arguments: label: D549
type_infered: string
name: retrieve_data
arguments: label: D108
type_infered: string
name: retrieve_data
arguments: label: D850
type_infered: string
name: retrieve_data
arguments: label: D742
type_infered: string
name: retrieve_data
arguments: label: D506
type_infered: string
name: retrieve_data
arguments: label: D105
type_infered: string
name: retrieve_data
arguments: label: D341
type_infered: string
name: retrieve_data
arguments: label: D70
type_infered: string
name: retrieve_data
arguments: label: D867
type_infered: string
name: retrieve_data
arguments: label: D832
type_infered: string
name: retrieve_data
arguments: label: D682
type_infered: string
name: retrieve_data
arguments: label: D37
type_infered: string
name: retrieve_data
arguments: label: D478
type_infered: string
name: retrieve_data
arguments: label: D214
type_infered: string
name: retrieve_data
arguments: label: D3
type_infered: string
name: retrieve_data
arguments: label: D126
type_infered: string
name: retrieve_data
arguments: label: D215
type_infered: string
name: retrieve_data
arguments: label: D1
type_infered: string
name: retrieve_data
arguments: label: D988
type_infered: string
name: retrieve_data
arguments: label: D140
type_infered: string
name: retrieve_data
arguments: label: D668
type_infered: string
name: retrieve_data
arguments: label: D898
type_infered: string
name: retrieve_data
arguments: label: D322
type_infered: string
name: retrieve_data
arguments: label: D208
type_infered: string
name: retrieve_data
arguments: label: D981
type_infered: string
name: retrieve_data
arguments: label: D287
type_infered: string
name: retrieve_data
arguments: label: D209
type_infered: string
name: retrieve_data
arguments: label: D279
type_infered: string
name: retrieve_data
arguments: label: D922
type_infered: string
name: retrieve_data
arguments: label: D172
type_infered: string
name: retrieve_data
arguments: label: D412
type_infered: string
name: retrieve_data
arguments: label: D377
type_infered: string
name: retrieve_data
arguments: label: D391
type_infered: string
name: retrieve_data
arguments: label: D62
type_infered: string
name: retrieve_data
arguments: label: D405
type_infered: string
name: retrieve_data
arguments: label: D901
type_infered: string
name: retrieve_data
arguments: label: D714
type_infered: string
name: retrieve_data
arguments: label: D388
type_infered: string
name: retrieve_data
arguments: label: D73
type_infered: string
name: retrieve_data
arguments: label: D702
type_infered: string
name: retrieve_data
arguments: label: D100
type_infered: string
name: retrieve_data
arguments: label: D183
type_infered: string
name: retrieve_data
arguments: label: D890
type_infered: string
name: retrieve_data
arguments: label: D175
type_infered: string
name: retrieve_data
arguments: label: D836
type_infered: string
name: retrieve_data
arguments: label: D574
type_infered: string
name: retrieve_data
arguments: label: D852
type_infered: string
name: retrieve_data
arguments: label: D373
type_infered: string
name: retrieve_data
arguments: label: D1004
type_infered: string
name: retrieve_data
arguments: label: D834
type_infered: string
name: retrieve_data
arguments: label: D891
type_infered: string
name: retrieve_data
arguments: label: D144
type_infered: string
name: retrieve_data
arguments: label: D103
type_infered: string
name: retrieve_data
arguments: label: D697
type_infered: string
name: retrieve_data
arguments: label: D40
type_infered: string
name: retrieve_data
arguments: label: D260
type_infered: string
name: retrieve_data
arguments: label: D687
type_infered: string
name: retrieve_data
arguments: label: D229
type_infered: string
name: retrieve_data
arguments: label: D970
type_infered: string
name: retrieve_data
arguments: label: D691
type_infered: string
name: retrieve_data
arguments: label: D197
type_infered: string
name: retrieve_data
arguments: label: D228
type_infered: string
name: retrieve_data
arguments: label: D779
type_infered: string
name: retrieve_data
arguments: label: D739
type_infered: string
name: retrieve_data
arguments: label: D871
type_infered: string
name: retrieve_data
arguments: label: D853
type_infered: string
name: retrieve_data
arguments: label: D754
type_infered: string
name: retrieve_data
arguments: label: D284
type_infered: string
name: retrieve_data
arguments: label: D810
type_infered: string
name: retrieve_data
arguments: label: D553
type_infered: string
name: retrieve_data
arguments: label: D954
type_infered: string
name: retrieve_data
arguments: label: D1002
type_infered: string
name: retrieve_data
arguments: label: D598
type_infered: string
name: retrieve_data
arguments: label: D132
type_infered: string
name: retrieve_data
arguments: label: D653
type_infered: string
name: retrieve_data
arguments: label: D297
type_infered: string
name: retrieve_data
arguments: label: D35
type_infered: string
name: retrieve_data
arguments: label: D752
type_infered: string
name: retrieve_data
arguments: label: D566
type_infered: string
name: retrieve_data
arguments: label: D761
type_infered: string
name: retrieve_data
arguments: label: D1017
type_infered: string
name: retrieve_data
arguments: label: D937
type_infered: string
name: retrieve_data
arguments: label: D2
type_infered: string
name: retrieve_data
arguments: label: D457
type_infered: string
name: retrieve_data
arguments: label: D632
type_infered: string
name: retrieve_data
arguments: label: D828
type_infered: string
name: retrieve_data
arguments: label: D16
type_infered: string
name: retrieve_data
arguments: label: D81
type_infered: string
name: retrieve_data
arguments: label: D605
type_infered: string
name: retrieve_data
arguments: label: D23
type_infered: string
name: retrieve_data
arguments: label: D926
type_infered: string
name: retrieve_data
arguments: label: D398
type_infered: string
name: retrieve_data
arguments: label: D600
type_infered: string
name: retrieve_data
arguments: label: D1023
type_infered: string
name: retrieve_data
arguments: label: D949
type_infered: string
name: retrieve_data
arguments: label: D429
type_infered: string

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


tool: D990: 


tool: D387:                      (slower, more stable)


tool: D4: General options:


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


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


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


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


tool: D108:                      language


tool: D850:    -m filename, --model filename


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


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


tool: D105:    -d filename, --data filename


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


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


tool: D867:    -y filename, --display filename


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


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


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


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


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


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


tool: D126:    -r filename, --read filename


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


tool: D1:                      the solver


tool: D988:    --min             minimization


tool: D140:    --max             maximization


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


tool: D898:    --noscale         do not scale problem


tool: D322:    -o filename, --output filename


tool: D208:                      write solution to filename in printable format


tool: D981:    -w filename, --write filename


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


tool: D209:    --bounds filename


tool: D279:                      write sensitivity bounds to filename in printable


tool: D922:                      format (LP only)


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


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


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


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


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


tool: D405:    --wfreemps filename


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


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


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


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


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


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


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


tool: D890: LP basis factorization options:


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


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


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


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


tool: D373:                      (default)


tool: D1004: Options specific to simplex solver:


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


tool: D891:    --dual            use dual simplex


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


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


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


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


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


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


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


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


tool: D691:    --nopresol        do not use presolver


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


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


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


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


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


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


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


tool: D284: Options specific to MIP solver:


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


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


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


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


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


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


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


tool: D297:                      useful for hard instances)


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


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


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


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


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


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


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


tool: D457:                      (assumes --intopt)


tool: D632:    --fpump           apply feasibility pump heuristic


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


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


tool: D81:    --cover           generate mixed cover cuts


tool: D605:    --clique          generate clique cuts


tool: D23:    --cuts            generate all cuts above


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


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


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


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


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


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