#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ copyright_notice();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ wait_any_key();
void print_help() {
  printf("\nTree Kernels in SVM-light %s : SVM Learning module %s\n",
         "V5.01-TK-1.2", "15.11.06");
  printf("by Alessandro Moschitti, moschitti@info.uniroma2.it\n");
  printf("University of Rome \"Tor Vergata\"\n\n");
  copyright_notice();
  printf("   usage: svm_learn [options] example_file model_file\n\n");
  printf("Arguments:\n");
  printf("         example_file-> file with training data\n");
  printf("         model_file  -> file to store learned decision rule in\n");
  printf("General options:\n");
  printf("         -?          -> this help\n");
  printf("         -v [0..3]   -> verbosity level (default 1)\n");
  printf("Learning options:\n");
  printf("         -z {c,r,p}  -> select between classification (c), "
         "regression (r),\n");
  printf("                        and preference ranking (p) (default "
         "classification)\n");
  printf("         -c float    -> C: trade-off between training error\n");
  printf("                        and margin (default [avg. x*x]^-1)\n");
  printf("         -w [0..]    -> epsilon width of tube for regression\n");
  printf("                        (default 0.1)\n");
  printf("         -j float    -> Cost: cost-factor, by which training errors "
         "on\n");
  printf("                        positive examples outweight errors on "
         "negative\n");
  printf("                        examples (default 1) (see [4])\n");
  printf(
      "         -b [0,1]    -> use biased hyperplane (i.e. x*w+b>0) instead\n");
  printf("                        of unbiased hyperplane (i.e. x*w>0) (default "
         "1)\n");
  printf("         -i [0,1]    -> remove inconsistent training examples\n");
  printf("                        and retrain (default 0)\n");
  printf("Performance estimation options:\n");
  printf(
      "         -x [0,1]    -> compute leave-one-out estimates (default 0)\n");
  printf("                        (see [5])\n");
  printf("         -o ]0..2]   -> value of rho for XiAlpha-estimator and for "
         "pruning\n");
  printf("                        leave-one-out computation (default 1.0) (see "
         "[2])\n");
  printf(
      "         -k [0..100] -> search depth for extended XiAlpha-estimator \n");
  printf("                        (default 0)\n");
  printf("Transduction options (see [3]):\n");
  printf("         -p [0..1]   -> fraction of unlabeled examples to be "
         "classified\n");
  printf("                        into the positive class (default is the "
         "ratio of\n");
  printf("                        positive and negative examples in the "
         "training data)\n");
  printf("Kernel options:\n");
  printf("         -t int      -> type of kernel function:\n");
  printf("                        0: linear (default)\n");
  printf("                        1: polynomial (s a*b+c)^d\n");
  printf("                        2: radial basis function exp(-gamma "
         "||a-b||^2)\n");
  printf("                        3: sigmoid tanh(s a*b + c)\n");
  printf("                        4: user defined kernel from kernel.h\n");
  printf("                        5: combination of forest and vector sets "
         "according to W, V, S, C options\n");
  printf("                        11: re-ranking based on trees (each instance "
         "must have two trees),\n");
  printf("                        12: re-ranking based on vectors (each "
         "instance must have two vectors)\n");
  printf("                        13: re-ranking based on both tree and "
         "vectors (each instance must have\n");
  printf("                            two trees and two vectors)  \n");
  printf("         -W [S,A]    -> with an 'S', a tree kernel is applied to the "
         "sequence of trees of two input\n");
  printf("                        forests and the results are summed;  \n");
  printf("                     -> with an 'A', a tree kernel is applied to all "
         "tree pairs from the two forests\n");
  printf("                        (default 'S')\n");
  printf("         -V [S,A]    -> same as before but regarding sequences of "
         "vectors are used (default 'S' and\n");
  printf("                        the type of vector-based kernel is specified "
         "by the option -S)\n");
  printf("         -S [0,4]    -> kernel to be used with vectors (default "
         "polynomial of degree 3,\n");
  printf("                        i.e. -S = 1 and -d = 3)\n");
  printf("         -C [*,+,T,V]-> combination operator between forests and "
         "vectors (default 'T')\n");
  printf("                     -> 'T' only the contribution from trees is used "
         "(specified by option -W)\n");
  printf("                     -> 'V' only the contribution from vectors is "
         "used (specified by option -V)\n");
  printf("                     -> '+' or '*' sum or multiplication of the "
         "contributions from vectors and \n");
  printf("                            trees (default T) \n");
  printf("         -D [0,1]    -> 0, SubTree kernel or 1, SubSet Tree kernels "
         "(default 1)\n");
  printf("         -L float    -> decay factor in tree kernel (default 0.4)\n");
  printf("         -S [0,4]    -> kernel to be used with vectors (default "
         "polynomial of degree 3, \n");
  printf("                        i.e. -S = 1 and -d = 3)\n");
  printf("         -T float    -> multiplicative constant for the contribution "
         "of tree kernels when -C = '+'\n");
  printf("         -N float    -> 0 = no normalization, 1 = tree "
         "normalization, 2 = vector normalization and \n");
  printf("                        3 = tree normalization of both trees and "
         "vectors. The normalization is applied \n");
  printf("                        to each individual tree or vector (default "
         "3).\n");
  printf("         -u string   -> parameter of user defined kernel\n");
  printf("         -d int      -> parameter d in polynomial kernel\n");
  printf("         -g float    -> parameter gamma in rbf kernel\n");
  printf("         -s float    -> parameter s in sigmoid/poly kernel\n");
  printf("         -r float    -> parameter c in sigmoid/poly kernel\n");
  printf("         -u string   -> parameter of user defined kernel\n");
  printf("Optimization options (see [1]):\n");
  printf(
      "         -q [2..]    -> maximum size of QP-subproblems (default 10)\n");
  printf("         -n [2..q]   -> number of new variables entering the working "
         "set\n");
  printf("                        in each iteration (default n = q). Set n<q "
         "to prevent\n");
  printf("                        zig-zagging.\n");
  printf("         -m [5..]    -> size of cache for kernel evaluations in MB "
         "(default 40)\n");
  printf("                        The larger the faster...\n");
  printf("         -e float    -> eps: Allow that error for termination "
         "criterion\n");
  printf("                        [y [w*x+b] - 1] >= eps (default 0.001)\n");
  printf(
      "         -h [5..]    -> number of iterations a variable needs to be\n");
  printf("                        optimal before considered for shrinking "
         "(default 100)\n");
  printf("         -f [0,1]    -> do final optimality check for variables "
         "removed\n");
  printf(
      "                        by shrinking. Although this test is usually \n");
  printf("                        positive, there is no guarantee that the "
         "optimum\n");
  printf("                        was found if the test is omitted. (default "
         "1)\n");
  printf("Output options:\n");
  printf(
      "         -l string   -> file to write predicted labels of unlabeled\n");
  printf("                        examples into after transductive learning\n");
  printf(
      "         -a string   -> write all alphas to this file after learning\n");
  printf(
      "                        (in the same order as in the training set)\n");
  wait_any_key();
  printf("\nMore details in:\n");
  printf("[1] T. Joachims, Making Large-Scale SVM Learning Practical. Advances "
         "in\n");
  printf("    Kernel Methods - Support Vector Learning, B. Schölkopf and C. "
         "Burges and\n");
  printf("    A. Smola (ed.), MIT Press, 1999.\n");
  printf(
      "[2] T. Joachims, Estimating the Generalization performance of an SVM\n");
  printf("    Efficiently. International Conference on Machine Learning "
         "(ICML), 2000.\n");
  printf("[3] T. Joachims, Transductive Inference for Text Classification "
         "using Support\n");
  printf("    Vector Machines. International Conference on Machine Learning "
         "(ICML),\n");
  printf("    1999.\n");
  printf("[4] K. Morik, P. Brockhausen, and T. Joachims, Combining statistical "
         "learning\n");
  printf("    with a knowledge-based approach - A case study in intensive care "
         " \n");
  printf("    monitoring. International Conference on Machine Learning (ICML), "
         "1999.\n");
  printf("[5] T. Joachims, Learning to Classify Text Using Support Vector\n");
  printf(
      "    Machines: Methods, Theory, and Algorithms. Dissertation, Kluwer,\n");
  printf("    2002.\n\n");
  printf("\nFor Tree-Kernel details:\n");
  printf("[6] A. Moschitti, A study on Convolution Kernels for Shallow "
         "Semantic Parsing.\n");
  printf("    In proceedings of the 42-th Conference on Association for "
         "Computational\n");
  printf("    Linguistic, (ACL-2004), Barcelona, Spain, 2004.\n\n");
  printf("[7] A. Moschitti, Making tree kernels practical for natural language "
         "learning.\n");
  printf("    In Proceedings of the Eleventh International Conference for "
         "Computational\n");
  printf("    Linguistics, (EACL-2006), Trento, Italy, 2006.\n\n");
}


x86 assembly (clang, -O0):
<print_help>:
push   %rbp
mov    %rsp,%rbp
lea    0xec5(%rip),%rdi
lea    0xef6(%rip),%rsi
lea    0xefc(%rip),%rdx
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xef7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xf1e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1030 <copyright_notice@plt>
lea    0xf2c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xf56(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xf54(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xf77(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xfa9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xfad(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xfc2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xfe9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xfee(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x102c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x106b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x109a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x10c8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x10f8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1111(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x114b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1185(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x11af(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x11e7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1222(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1253(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1276(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1289(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x12c0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x12d5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1313(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1350(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1388(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x139f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x13b2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x13ed(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1429(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1469(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x146c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1490(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x14af(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x14d4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x150e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1534(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1564(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x15b8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1606(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1657(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x16a9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x16d5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x172c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x175d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x17b5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x17ce(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1825(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x186f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x18ba(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x18dd(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1927(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1978(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x19cb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1a1e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1a40(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1a83(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1ab8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x183c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1af6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1b4c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1ba3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1bfe(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1c38(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1c64(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1c90(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1cb9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1ce7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1bf2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1d07(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1d1a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1d51(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1d8d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1dce(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1de6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1e29(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1e4d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1e88(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1eba(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1ef1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1f32(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1f6d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1fa5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x1fe1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x201a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x201d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2054(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2089(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x20c1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1040 <wait_any_key@plt>
lea    0x20f0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x20f5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2130(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2171(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2189(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x21c1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2200(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2241(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x227e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x227b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x22bc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x22f6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2334(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2367(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x239f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x239d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x23aa(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x23ec(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x242b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2453(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x2495(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x24d6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_help>:
push   %rbx
lea    0xeb8(%rip),%rdi
lea    0xee9(%rip),%rsi
lea    0xeef(%rip),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xeea(%rip),%rdi
call   1040 <puts@plt>
lea    0xf12(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1030 <copyright_notice@plt>
lea    0xf21(%rip),%rdi
call   1040 <puts@plt>
lea    0xf4c(%rip),%rdi
call   1040 <puts@plt>
lea    0xf4b(%rip),%rdi
call   1040 <puts@plt>
lea    0xf6f(%rip),%rdi
call   1040 <puts@plt>
lea    0xfa2(%rip),%rdi
call   1040 <puts@plt>
lea    0xfa7(%rip),%rdi
call   1040 <puts@plt>
lea    0xfbd(%rip),%rdi
call   1040 <puts@plt>
lea    0xfe5(%rip),%rdi
call   1040 <puts@plt>
lea    0xfeb(%rip),%rdi
call   1040 <puts@plt>
lea    0x102a(%rip),%rdi
call   1040 <puts@plt>
lea    0x106a(%rip),%rdi
call   1040 <puts@plt>
lea    0x109a(%rip),%rdi
call   1040 <puts@plt>
lea    0x10c9(%rip),%rdi
call   1040 <puts@plt>
lea    0x10fa(%rip),%rdi
call   1040 <puts@plt>
lea    0x1114(%rip),%rdi
call   1040 <puts@plt>
lea    0x114f(%rip),%rdi
call   1040 <puts@plt>
lea    0x118a(%rip),%rdi
call   1040 <puts@plt>
lea    0x11b5(%rip),%rdi
call   1040 <puts@plt>
lea    0x11ee(%rip),%rdi
call   1040 <puts@plt>
lea    0x122a(%rip),%rdi
call   1040 <puts@plt>
lea    0x125c(%rip),%rdi
call   1040 <puts@plt>
lea    0x1280(%rip),%rdi
call   1040 <puts@plt>
lea    0x1294(%rip),%rdi
call   1040 <puts@plt>
lea    0x12cc(%rip),%rdi
call   1040 <puts@plt>
lea    0x12e2(%rip),%rdi
call   1040 <puts@plt>
lea    0x1321(%rip),%rdi
call   1040 <puts@plt>
lea    0x135f(%rip),%rdi
call   1040 <puts@plt>
lea    0x1398(%rip),%rdi
call   1040 <puts@plt>
lea    0x13b0(%rip),%rdi
call   1040 <puts@plt>
lea    0x13c4(%rip),%rdi
call   1040 <puts@plt>
lea    0x1400(%rip),%rdi
call   1040 <puts@plt>
lea    0x143d(%rip),%rdi
call   1040 <puts@plt>
lea    0x147e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1482(%rip),%rdi
call   1040 <puts@plt>
lea    0x14a7(%rip),%rdi
call   1040 <puts@plt>
lea    0x14c7(%rip),%rdi
call   1040 <puts@plt>
lea    0x14ed(%rip),%rdi
call   1040 <puts@plt>
lea    0x1528(%rip),%rdi
call   1040 <puts@plt>
lea    0x154f(%rip),%rdi
call   1040 <puts@plt>
lea    0x1580(%rip),%rdi
call   1040 <puts@plt>
lea    0x15d5(%rip),%rdi
call   1040 <puts@plt>
lea    0x1624(%rip),%rdi
call   1040 <puts@plt>
lea    0x1676(%rip),%rdi
call   1040 <puts@plt>
lea    0x16c9(%rip),%rdi
call   1040 <puts@plt>
lea    0x16f6(%rip),%rdi
call   1040 <puts@plt>
lea    0x174e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1780(%rip),%rdi
call   1040 <puts@plt>
lea    0x17d9(%rip),%rdi
call   1040 <puts@plt>
lea    0x17f3(%rip),%rdi
call   1040 <puts@plt>
lea    0x184b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1896(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b71(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0x18d3(%rip),%rdi
call   1040 <puts@plt>
lea    0x191e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1970(%rip),%rdi
call   1040 <puts@plt>
lea    0x19c4(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a18(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a3b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a7f(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ab5(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0x1b2a(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b81(%rip),%rdi
call   1040 <puts@plt>
lea    0x1bd9(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c35(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d55(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0x1c61(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c8e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1cb8(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ce7(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0x1d47(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d5b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d93(%rip),%rdi
call   1040 <puts@plt>
lea    0x1dd0(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e12(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e2b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e6f(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e94(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ed0(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f03(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f3b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f7d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1fb9(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ff2(%rip),%rdi
call   1040 <puts@plt>
lea    0x202f(%rip),%rdi
call   1040 <puts@plt>
lea    0x2069(%rip),%rdi
call   1040 <puts@plt>
lea    0x206d(%rip),%rdi
call   1040 <puts@plt>
lea    0x20a5(%rip),%rdi
call   1040 <puts@plt>
lea    0x20db(%rip),%rdi
call   1040 <puts@plt>
lea    0x2114(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1050 <wait_any_key@plt>
lea    0x2144(%rip),%rdi
call   1040 <puts@plt>
lea    0x214a(%rip),%rdi
call   1040 <puts@plt>
lea    0x2186(%rip),%rdi
call   1040 <puts@plt>
lea    0x21c8(%rip),%rdi
call   1040 <puts@plt>
lea    0x21e1(%rip),%rdi
call   1040 <puts@plt>
lea    0x221a(%rip),%rdi
call   1040 <puts@plt>
lea    0x225a(%rip),%rdi
call   1040 <puts@plt>
lea    0x229c(%rip),%rdi
call   1040 <puts@plt>
lea    0x22da(%rip),%rdi
call   1040 <puts@plt>
lea    0x22d8(%rip),%rdi
call   1040 <puts@plt>
lea    0x231a(%rip),%rdi
call   1040 <puts@plt>
lea    0x2355(%rip),%rdi
call   1040 <puts@plt>
lea    0x2394(%rip),%rdi
call   1040 <puts@plt>
lea    0x23c8(%rip),%rdi
call   1040 <puts@plt>
lea    0x2401(%rip),%rdi
call   1040 <puts@plt>
lea    0x2400(%rip),%rdi
call   1040 <puts@plt>
lea    0x240e(%rip),%rdi
call   1040 <puts@plt>
lea    0x2451(%rip),%rdi
call   1040 <puts@plt>
lea    0x2491(%rip),%rdi
call   1040 <puts@plt>
lea    0x24ba(%rip),%rdi
call   1040 <puts@plt>
lea    0x24fd(%rip),%rdi
call   1040 <puts@plt>
lea    0x253f(%rip),%rdi
pop    %rbx
jmp    1040 <puts@plt>

LLVM IR (-O0):
@.str = [56 x i8] c"\0ATree Kernels in SVM-light %s : SVM Learning module %s\0A\00"
@.str.1 = [13 x i8] c"V5.01-TK-1.2\00"
@.str.2 = [9 x i8] c"15.11.06\00"
@.str.3 = [53 x i8] c"by Alessandro Moschitti, moschitti@info.uniroma2.it\0A\00"
@.str.4 = [35 x i8] c"University of Rome \22Tor Vergata\22\0A\0A\00"
@.str.5 = [56 x i8] c" usage: svm_learn [options] example_file model_file\0A\0A\00"
@.str.6 = [12 x i8] c"Arguments:\0A\00"
@.str.7 = [49 x i8] c" example_file-> file with training data\0A\00"
@.str.8 = [64 x i8] c" model_file -> file to store learned decision rule in\0A\00"
@.str.9 = [18 x i8] c"General options:\0A\00"
@.str.10 = [35 x i8] c" -? -> this help\0A\00"
@.str.11 = [53 x i8] c" -v [0..3] -> verbosity level (default 1)\0A\00"
@.str.12 = [19 x i8] c"Learning options:\0A\00"
@.str.13 = [76 x i8] c" -z {c,r,p} -> select between classification (c), regression (r),\0A\00"
@.str.14 = [77 x i8] c" and preference ranking (p) (default classification)\0A\00"
@.str.15 = [61 x i8] c" -c float -> C: trade-off between training error\0A\00"
@.str.16 = [60 x i8] c" and margin (default [avg. x*x]^-1)\0A\00"
@.str.17 = [62 x i8] c" -w [0..] -> epsilon width of tube for regression\0A\00"
@.str.18 = [39 x i8] c" (default 0.1)\0A\00"
@.str.19 = [72 x i8] c" -j float -> Cost: cost-factor, by which training errors on\0A\00"
@.str.20 = [72 x i8] c" positive examples outweight errors on negative\0A\00"
@.str.21 = [56 x i8] c" examples (default 1) (see [4])\0A\00"
@.str.22 = [70 x i8] c" -b [0,1] -> use biased hyperplane (i.e. x*w+b>0) instead\0A\00"
@.str.23 = [73 x i8] c" of unbiased hyperplane (i.e. x*w>0) (default 1)\0A\00"
@.str.24 = [63 x i8] c" -i [0,1] -> remove inconsistent training examples\0A\00"
@.str.25 = [49 x i8] c" and retrain (default 0)\0A\00"
@.str.26 = [33 x i8] c"Performance estimation options:\0A\00"
@.str.27 = [69 x i8] c" -x [0,1] -> compute leave-one-out estimates (default 0)\0A\00"
@.str.28 = [35 x i8] c" (see [5])\0A\00"
@.str.29 = [76 x i8] c" -o ]0..2] -> value of rho for XiAlpha-estimator and for pruning\0A\00"
@.str.30 = [75 x i8] c" leave-one-out computation (default 1.0) (see [2])\0A\00"
@.str.31 = [70 x i8] c" -k [0..100] -> search depth for extended XiAlpha-estimator \0A\00"
@.str.32 = [37 x i8] c" (default 0)\0A\00"
@.str.33 = [33 x i8] c"Transduction options (see [3]):\0A\00"
@.str.34 = [73 x i8] c" -p [0..1] -> fraction of unlabeled examples to be classified\0A\00"
@.str.35 = [74 x i8] c" into the positive class (default is the ratio of\0A\00"
@.str.36 = [78 x i8] c" positive and negative examples in the training data)\0A\00"
@.str.37 = [17 x i8] c"Kernel options:\0A\00"
@.str.38 = [50 x i8] c" -t int -> type of kernel function:\0A\00"
@.str.39 = [45 x i8] c" 0: linear (default)\0A\00"
@.str.40 = [51 x i8] c" 1: polynomial (s a*b+c)^d\0A\00"
@.str.41 = [72 x i8] c" 2: radial basis function exp(-gamma ||a-b||^2)\0A\00"
@.str.42 = [52 x i8] c" 3: sigmoid tanh(s a*b + c)\0A\00"
@.str.43 = [62 x i8] c" 4: user defined kernel from kernel.h\0A\00"
@.str.44 = [98 x i8] c" 5: combination of forest and vector sets according to W, V, S, C options\0A\00"
@.str.45 = [92 x i8] c" 11: re-ranking based on trees (each instance must have two trees),\0A\00"
@.str.46 = [95 x i8] c" 12: re-ranking based on vectors (each instance must have two vectors)\0A\00"
@.str.47 = [96 x i8] c" 13: re-ranking based on both tree and vectors (each instance must have\0A\00"
@.str.48 = [58 x i8] c" two trees and two vectors) \0A\00"
@.str.49 = [101 x i8] c" -W [S,A] -> with an 'S', a tree kernel is applied to the sequence of trees of two input\0A\00"
@.str.50 = [63 x i8] c" forests and the results are summed; \0A\00"
@.str.51 = [102 x i8] c" -> with an 'A', a tree kernel is applied to all tree pairs from the two forests\0A\00"
@.str.52 = [39 x i8] c" (default 'S')\0A\00"
@.str.53 = [101 x i8] c" -V [S,A] -> same as before but regarding sequences of vectors are used (default 'S' and\0A\00"
@.str.54 = [88 x i8] c" the type of vector-based kernel is specified by the option -S)\0A\00"
@.str.55 = [89 x i8] c" -S [0,4] -> kernel to be used with vectors (default polynomial of degree 3,\0A\00"
@.str.56 = [49 x i8] c" i.e. -S = 1 and -d = 3)\0A\00"
@.str.57 = [88 x i8] c" -C [*,+,T,V]-> combination operator between forests and vectors (default 'T')\0A\00"
@.str.58 = [95 x i8] c" -> 'T' only the contribution from trees is used (specified by option -W)\0A\00"
@.str.59 = [97 x i8] c" -> 'V' only the contribution from vectors is used (specified by option -V)\0A\00"
@.str.60 = [97 x i8] c" -> '+' or '*' sum or multiplication of the contributions from vectors and \0A\00"
@.str.61 = [48 x i8] c" trees (default T) \0A\00"
@.str.62 = [81 x i8] c" -D [0,1] -> 0, SubTree kernel or 1, SubSet Tree kernels (default 1)\0A\00"
@.str.63 = [67 x i8] c" -L float -> decay factor in tree kernel (default 0.4)\0A\00"
@.str.64 = [90 x i8] c" -S [0,4] -> kernel to be used with vectors (default polynomial of degree 3, \0A\00"
@.str.65 = [100 x i8] c" -T float -> multiplicative constant for the contribution of tree kernels when -C = '+'\0A\00"
@.str.66 = [101 x i8] c" -N float -> 0 = no normalization, 1 = tree normalization, 2 = vector normalization and \0A\00"
@.str.67 = [105 x i8] c" 3 = tree normalization of both trees and vectors. The normalization is applied \0A\00"
@.str.68 = [72 x i8] c" to each individual tree or vector (default 3).\0A\00"
@.str.69 = [58 x i8] c" -u string -> parameter of user defined kernel\0A\00"
@.str.70 = [58 x i8] c" -d int -> parameter d in polynomial kernel\0A\00"
@.str.71 = [55 x i8] c" -g float -> parameter gamma in rbf kernel\0A\00"
@.str.72 = [60 x i8] c" -s float -> parameter s in sigmoid/poly kernel\0A\00"
@.str.73 = [60 x i8] c" -r float -> parameter c in sigmoid/poly kernel\0A\00"
@.str.74 = [33 x i8] c"Optimization options (see [1]):\0A\00"
@.str.75 = [69 x i8] c" -q [2..] -> maximum size of QP-subproblems (default 10)\0A\00"
@.str.76 = [74 x i8] c" -n [2..q] -> number of new variables entering the working set\0A\00"
@.str.77 = [79 x i8] c" in each iteration (default n = q). Set n<q to prevent\0A\00"
@.str.78 = [38 x i8] c" zig-zagging.\0A\00"
@.str.79 = [81 x i8] c" -m [5..] -> size of cache for kernel evaluations in MB (default 40)\0A\00"
@.str.80 = [50 x i8] c" The larger the faster...\0A\00"
@.str.81 = [73 x i8] c" -e float -> eps: Allow that error for termination criterion\0A\00"
@.str.82 = [64 x i8] c" [y [w*x+b] - 1] >= eps (default 0.001)\0A\00"
@.str.83 = [69 x i8] c" -h [5..] -> number of iterations a variable needs to be\0A\00"
@.str.84 = [79 x i8] c" optimal before considered for shrinking (default 100)\0A\00"
@.str.85 = [73 x i8] c" -f [0,1] -> do final optimality check for variables removed\0A\00"
@.str.86 = [70 x i8] c" by shrinking. Although this test is usually \0A\00"
@.str.87 = [74 x i8] c" positive, there is no guarantee that the optimum\0A\00"
@.str.88 = [71 x i8] c" was found if the test is omitted. (default 1)\0A\00"
@.str.89 = [17 x i8] c"Output options:\0A\00"
@.str.90 = [69 x i8] c" -l string -> file to write predicted labels of unlabeled\0A\00"
@.str.91 = [67 x i8] c" examples into after transductive learning\0A\00"
@.str.92 = [70 x i8] c" -a string -> write all alphas to this file after learning\0A\00"
@.str.93 = [68 x i8] c" (in the same order as in the training set)\0A\00"
@.str.94 = [19 x i8] c"\0AMore details in:\0A\00"
@.str.95 = [73 x i8] c"[1] T. Joachims, Making Large-Scale SVM Learning Practical. Advances in\0A\00"
@.str.96 = [79 x i8] c" Kernel Methods - Support Vector Learning, B. Sch\C3\B6lkopf and C. Burges and\0A\00"
@.str.97 = [38 x i8] c" A. Smola (ed.), MIT Press, 1999.\0A\00"
@.str.98 = [70 x i8] c"[2] T. Joachims, Estimating the Generalization performance of an SVM\0A\00"
@.str.99 = [77 x i8] c" Efficiently. International Conference on Machine Learning (ICML), 2000.\0A\00"
@.str.100 = [79 x i8] c"[3] T. Joachims, Transductive Inference for Text Classification using Support\0A\00"
@.str.101 = [75 x i8] c" Vector Machines. International Conference on Machine Learning (ICML),\0A\00"
@.str.102 = [11 x i8] c" 1999.\0A\00"
@.str.103 = [79 x i8] c"[4] K. Morik, P. Brockhausen, and T. Joachims, Combining statistical learning\0A\00"
@.str.104 = [72 x i8] c" with a knowledge-based approach - A case study in intensive care \0A\00"
@.str.105 = [76 x i8] c" monitoring. International Conference on Machine Learning (ICML), 1999.\0A\00"
@.str.106 = [65 x i8] c"[5] T. Joachims, Learning to Classify Text Using Support Vector\0A\00"
@.str.107 = [70 x i8] c" Machines: Methods, Theory, and Algorithms. Dissertation, Kluwer,\0A\00"
@.str.108 = [12 x i8] c" 2002.\0A\0A\00"
@.str.109 = [27 x i8] c"\0AFor Tree-Kernel details:\0A\00"
@.str.110 = [80 x i8] c"[6] A. Moschitti, A study on Convolution Kernels for Shallow Semantic Parsing.\0A\00"
@.str.111 = [77 x i8] c" In proceedings of the 42-th Conference on Association for Computational\0A\00"
@.str.112 = [54 x i8] c" Linguistic, (ACL-2004), Barcelona, Spain, 2004.\0A\0A\00"
@.str.113 = [80 x i8] c"[7] A. Moschitti, Making tree kernels practical for natural language learning.\0A\00"
@.str.114 = [79 x i8] c" In Proceedings of the Eleventh International Conference for Computational\0A\00"
@.str.115 = [53 x i8] c" Linguistics, (EACL-2006), Trento, Italy, 2006.\0A\0A\00"
define void @print_help() {
%1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
%2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.3, i64 0, i64 0))
%3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.4, i64 0, i64 0))
%4 = call i32 (...) @copyright_notice()
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.5, i64 0, i64 0))
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0))
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.7, i64 0, i64 0))
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.8, i64 0, i64 0))
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0))
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.10, i64 0, i64 0))
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i64 0, i64 0))
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.13, i64 0, i64 0))
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.14, i64 0, i64 0))
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.15, i64 0, i64 0))
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.16, i64 0, i64 0))
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.17, i64 0, i64 0))
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.18, i64 0, i64 0))
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.19, i64 0, i64 0))
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.20, i64 0, i64 0))
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.21, i64 0, i64 0))
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.22, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.23, i64 0, i64 0))
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.24, i64 0, i64 0))
%25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.25, i64 0, i64 0))
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.26, i64 0, i64 0))
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.27, i64 0, i64 0))
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.28, i64 0, i64 0))
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.29, i64 0, i64 0))
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.30, i64 0, i64 0))
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.31, i64 0, i64 0))
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.32, i64 0, i64 0))
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.33, i64 0, i64 0))
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.34, i64 0, i64 0))
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.35, i64 0, i64 0))
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.36, i64 0, i64 0))
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.37, i64 0, i64 0))
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.38, i64 0, i64 0))
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.39, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.40, i64 0, i64 0))
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.41, i64 0, i64 0))
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.42, i64 0, i64 0))
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.43, i64 0, i64 0))
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.44, i64 0, i64 0))
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.45, i64 0, i64 0))
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.46, i64 0, i64 0))
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str.47, i64 0, i64 0))
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.48, i64 0, i64 0))
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([101 x i8], [101 x i8]* @.str.49, i64 0, i64 0))
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.50, i64 0, i64 0))
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.51, i64 0, i64 0))
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.52, i64 0, i64 0))
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([101 x i8], [101 x i8]* @.str.53, i64 0, i64 0))
%54 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.54, i64 0, i64 0))
%55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.55, i64 0, i64 0))
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.56, i64 0, i64 0))
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.57, i64 0, i64 0))
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.58, i64 0, i64 0))
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.59, i64 0, i64 0))
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.60, i64 0, i64 0))
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.61, i64 0, i64 0))
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.62, i64 0, i64 0))
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.63, i64 0, i64 0))
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.64, i64 0, i64 0))
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.56, i64 0, i64 0))
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.65, i64 0, i64 0))
%67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([101 x i8], [101 x i8]* @.str.66, i64 0, i64 0))
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.67, i64 0, i64 0))
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.68, i64 0, i64 0))
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.69, i64 0, i64 0))
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.70, i64 0, i64 0))
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.71, i64 0, i64 0))
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.72, i64 0, i64 0))
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.73, i64 0, i64 0))
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.69, i64 0, i64 0))
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.74, i64 0, i64 0))
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.75, i64 0, i64 0))
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.76, i64 0, i64 0))
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.77, i64 0, i64 0))
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.78, i64 0, i64 0))
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.79, i64 0, i64 0))
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.80, i64 0, i64 0))
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.81, i64 0, i64 0))
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.82, i64 0, i64 0))
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.83, i64 0, i64 0))
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.84, i64 0, i64 0))
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.85, i64 0, i64 0))
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.86, i64 0, i64 0))
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.87, i64 0, i64 0))
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.88, i64 0, i64 0))
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.89, i64 0, i64 0))
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.90, i64 0, i64 0))
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.91, i64 0, i64 0))
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.92, i64 0, i64 0))
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.93, i64 0, i64 0))
%96 = call i32 (...) @wait_any_key()
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.94, i64 0, i64 0))
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.95, i64 0, i64 0))
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.96, i64 0, i64 0))
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.97, i64 0, i64 0))
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.98, i64 0, i64 0))
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.99, i64 0, i64 0))
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.100, i64 0, i64 0))
%104 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.101, i64 0, i64 0))
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.102, i64 0, i64 0))
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.103, i64 0, i64 0))
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.104, i64 0, i64 0))
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.105, i64 0, i64 0))
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.106, i64 0, i64 0))
%110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.107, i64 0, i64 0))
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.108, i64 0, i64 0))
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.109, i64 0, i64 0))
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.110, i64 0, i64 0))
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.111, i64 0, i64 0))
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.112, i64 0, i64 0))
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.113, i64 0, i64 0))
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.114, i64 0, i64 0))
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.115, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [56 x i8] c"\0ATree Kernels in SVM-light %s : SVM Learning module %s\0A\00"
@.str.1 = [13 x i8] c"V5.01-TK-1.2\00"
@.str.2 = [9 x i8] c"15.11.06\00"
@str = [52 x i8] c"by Alessandro Moschitti, moschitti@info.uniroma2.it\00"
@str.116 = [34 x i8] c"University of Rome \22Tor Vergata\22\0A\00"
@str.117 = [55 x i8] c" usage: svm_learn [options] example_file model_file\0A\00"
@str.118 = [11 x i8] c"Arguments:\00"
@str.119 = [48 x i8] c" example_file-> file with training data\00"
@str.120 = [63 x i8] c" model_file -> file to store learned decision rule in\00"
@str.121 = [17 x i8] c"General options:\00"
@str.122 = [34 x i8] c" -? -> this help\00"
@str.123 = [52 x i8] c" -v [0..3] -> verbosity level (default 1)\00"
@str.124 = [18 x i8] c"Learning options:\00"
@str.125 = [75 x i8] c" -z {c,r,p} -> select between classification (c), regression (r),\00"
@str.126 = [76 x i8] c" and preference ranking (p) (default classification)\00"
@str.127 = [60 x i8] c" -c float -> C: trade-off between training error\00"
@str.128 = [59 x i8] c" and margin (default [avg. x*x]^-1)\00"
@str.129 = [61 x i8] c" -w [0..] -> epsilon width of tube for regression\00"
@str.130 = [38 x i8] c" (default 0.1)\00"
@str.131 = [71 x i8] c" -j float -> Cost: cost-factor, by which training errors on\00"
@str.132 = [71 x i8] c" positive examples outweight errors on negative\00"
@str.133 = [55 x i8] c" examples (default 1) (see [4])\00"
@str.134 = [69 x i8] c" -b [0,1] -> use biased hyperplane (i.e. x*w+b>0) instead\00"
@str.135 = [72 x i8] c" of unbiased hyperplane (i.e. x*w>0) (default 1)\00"
@str.136 = [62 x i8] c" -i [0,1] -> remove inconsistent training examples\00"
@str.137 = [48 x i8] c" and retrain (default 0)\00"
@str.138 = [32 x i8] c"Performance estimation options:\00"
@str.139 = [68 x i8] c" -x [0,1] -> compute leave-one-out estimates (default 0)\00"
@str.140 = [34 x i8] c" (see [5])\00"
@str.141 = [75 x i8] c" -o ]0..2] -> value of rho for XiAlpha-estimator and for pruning\00"
@str.142 = [74 x i8] c" leave-one-out computation (default 1.0) (see [2])\00"
@str.143 = [69 x i8] c" -k [0..100] -> search depth for extended XiAlpha-estimator \00"
@str.144 = [36 x i8] c" (default 0)\00"
@str.145 = [32 x i8] c"Transduction options (see [3]):\00"
@str.146 = [72 x i8] c" -p [0..1] -> fraction of unlabeled examples to be classified\00"
@str.147 = [73 x i8] c" into the positive class (default is the ratio of\00"
@str.148 = [77 x i8] c" positive and negative examples in the training data)\00"
@str.149 = [16 x i8] c"Kernel options:\00"
@str.150 = [49 x i8] c" -t int -> type of kernel function:\00"
@str.151 = [44 x i8] c" 0: linear (default)\00"
@str.152 = [50 x i8] c" 1: polynomial (s a*b+c)^d\00"
@str.153 = [71 x i8] c" 2: radial basis function exp(-gamma ||a-b||^2)\00"
@str.154 = [51 x i8] c" 3: sigmoid tanh(s a*b + c)\00"
@str.155 = [61 x i8] c" 4: user defined kernel from kernel.h\00"
@str.156 = [97 x i8] c" 5: combination of forest and vector sets according to W, V, S, C options\00"
@str.157 = [91 x i8] c" 11: re-ranking based on trees (each instance must have two trees),\00"
@str.158 = [94 x i8] c" 12: re-ranking based on vectors (each instance must have two vectors)\00"
@str.159 = [95 x i8] c" 13: re-ranking based on both tree and vectors (each instance must have\00"
@str.160 = [57 x i8] c" two trees and two vectors) \00"
@str.161 = [100 x i8] c" -W [S,A] -> with an 'S', a tree kernel is applied to the sequence of trees of two input\00"
@str.162 = [62 x i8] c" forests and the results are summed; \00"
@str.163 = [101 x i8] c" -> with an 'A', a tree kernel is applied to all tree pairs from the two forests\00"
@str.164 = [38 x i8] c" (default 'S')\00"
@str.165 = [100 x i8] c" -V [S,A] -> same as before but regarding sequences of vectors are used (default 'S' and\00"
@str.166 = [87 x i8] c" the type of vector-based kernel is specified by the option -S)\00"
@str.167 = [88 x i8] c" -S [0,4] -> kernel to be used with vectors (default polynomial of degree 3,\00"
@str.169 = [87 x i8] c" -C [*,+,T,V]-> combination operator between forests and vectors (default 'T')\00"
@str.170 = [94 x i8] c" -> 'T' only the contribution from trees is used (specified by option -W)\00"
@str.171 = [96 x i8] c" -> 'V' only the contribution from vectors is used (specified by option -V)\00"
@str.172 = [96 x i8] c" -> '+' or '*' sum or multiplication of the contributions from vectors and \00"
@str.173 = [47 x i8] c" trees (default T) \00"
@str.174 = [80 x i8] c" -D [0,1] -> 0, SubTree kernel or 1, SubSet Tree kernels (default 1)\00"
@str.175 = [66 x i8] c" -L float -> decay factor in tree kernel (default 0.4)\00"
@str.176 = [89 x i8] c" -S [0,4] -> kernel to be used with vectors (default polynomial of degree 3, \00"
@str.177 = [48 x i8] c" i.e. -S = 1 and -d = 3)\00"
@str.178 = [99 x i8] c" -T float -> multiplicative constant for the contribution of tree kernels when -C = '+'\00"
@str.179 = [100 x i8] c" -N float -> 0 = no normalization, 1 = tree normalization, 2 = vector normalization and \00"
@str.180 = [104 x i8] c" 3 = tree normalization of both trees and vectors. The normalization is applied \00"
@str.181 = [71 x i8] c" to each individual tree or vector (default 3).\00"
@str.183 = [57 x i8] c" -d int -> parameter d in polynomial kernel\00"
@str.184 = [54 x i8] c" -g float -> parameter gamma in rbf kernel\00"
@str.185 = [59 x i8] c" -s float -> parameter s in sigmoid/poly kernel\00"
@str.186 = [59 x i8] c" -r float -> parameter c in sigmoid/poly kernel\00"
@str.187 = [57 x i8] c" -u string -> parameter of user defined kernel\00"
@str.188 = [32 x i8] c"Optimization options (see [1]):\00"
@str.189 = [68 x i8] c" -q [2..] -> maximum size of QP-subproblems (default 10)\00"
@str.190 = [73 x i8] c" -n [2..q] -> number of new variables entering the working set\00"
@str.191 = [78 x i8] c" in each iteration (default n = q). Set n<q to prevent\00"
@str.192 = [37 x i8] c" zig-zagging.\00"
@str.193 = [80 x i8] c" -m [5..] -> size of cache for kernel evaluations in MB (default 40)\00"
@str.194 = [49 x i8] c" The larger the faster...\00"
@str.195 = [72 x i8] c" -e float -> eps: Allow that error for termination criterion\00"
@str.196 = [63 x i8] c" [y [w*x+b] - 1] >= eps (default 0.001)\00"
@str.197 = [68 x i8] c" -h [5..] -> number of iterations a variable needs to be\00"
@str.198 = [78 x i8] c" optimal before considered for shrinking (default 100)\00"
@str.199 = [72 x i8] c" -f [0,1] -> do final optimality check for variables removed\00"
@str.200 = [69 x i8] c" by shrinking. Although this test is usually \00"
@str.201 = [73 x i8] c" positive, there is no guarantee that the optimum\00"
@str.202 = [70 x i8] c" was found if the test is omitted. (default 1)\00"
@str.203 = [16 x i8] c"Output options:\00"
@str.204 = [68 x i8] c" -l string -> file to write predicted labels of unlabeled\00"
@str.205 = [66 x i8] c" examples into after transductive learning\00"
@str.206 = [69 x i8] c" -a string -> write all alphas to this file after learning\00"
@str.207 = [67 x i8] c" (in the same order as in the training set)\00"
@str.208 = [18 x i8] c"\0AMore details in:\00"
@str.209 = [72 x i8] c"[1] T. Joachims, Making Large-Scale SVM Learning Practical. Advances in\00"
@str.210 = [78 x i8] c" Kernel Methods - Support Vector Learning, B. Sch\C3\B6lkopf and C. Burges and\00"
@str.211 = [37 x i8] c" A. Smola (ed.), MIT Press, 1999.\00"
@str.212 = [69 x i8] c"[2] T. Joachims, Estimating the Generalization performance of an SVM\00"
@str.213 = [76 x i8] c" Efficiently. International Conference on Machine Learning (ICML), 2000.\00"
@str.214 = [78 x i8] c"[3] T. Joachims, Transductive Inference for Text Classification using Support\00"
@str.215 = [74 x i8] c" Vector Machines. International Conference on Machine Learning (ICML),\00"
@str.216 = [10 x i8] c" 1999.\00"
@str.217 = [78 x i8] c"[4] K. Morik, P. Brockhausen, and T. Joachims, Combining statistical learning\00"
@str.218 = [71 x i8] c" with a knowledge-based approach - A case study in intensive care \00"
@str.219 = [75 x i8] c" monitoring. International Conference on Machine Learning (ICML), 1999.\00"
@str.220 = [64 x i8] c"[5] T. Joachims, Learning to Classify Text Using Support Vector\00"
@str.221 = [69 x i8] c" Machines: Methods, Theory, and Algorithms. Dissertation, Kluwer,\00"
@str.222 = [11 x i8] c" 2002.\0A\00"
@str.223 = [26 x i8] c"\0AFor Tree-Kernel details:\00"
@str.224 = [79 x i8] c"[6] A. Moschitti, A study on Convolution Kernels for Shallow Semantic Parsing.\00"
@str.225 = [76 x i8] c" In proceedings of the 42-th Conference on Association for Computational\00"
@str.226 = [53 x i8] c" Linguistic, (ACL-2004), Barcelona, Spain, 2004.\0A\00"
@str.227 = [79 x i8] c"[7] A. Moschitti, Making tree kernels practical for natural language learning.\00"
@str.228 = [78 x i8] c" In Proceedings of the Eleventh International Conference for Computational\00"
@str.229 = [52 x i8] c" Linguistics, (EACL-2006), Trento, Italy, 2006.\0A\00"
define void @print_help() {
%1 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @str, i64 0, i64 0))
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.116, i64 0, i64 0))
%4 = tail call i32 (...) @copyright_notice()
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @str.117, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.118, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.119, i64 0, i64 0))
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.120, i64 0, i64 0))
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.121, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.122, i64 0, i64 0))
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @str.123, i64 0, i64 0))
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.124, i64 0, i64 0))
%13 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.125, i64 0, i64 0))
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.126, i64 0, i64 0))
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @str.127, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str.128, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str.129, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.130, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.131, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.132, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @str.133, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.134, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.135, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @str.136, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.137, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.138, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.139, i64 0, i64 0))
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.140, i64 0, i64 0))
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.141, i64 0, i64 0))
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.142, i64 0, i64 0))
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.143, i64 0, i64 0))
%32 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str.144, i64 0, i64 0))
%33 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.145, i64 0, i64 0))
%34 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.146, i64 0, i64 0))
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @str.147, i64 0, i64 0))
%36 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @str.148, i64 0, i64 0))
%37 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str.149, i64 0, i64 0))
%38 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str.150, i64 0, i64 0))
%39 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @str.151, i64 0, i64 0))
%40 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @str.152, i64 0, i64 0))
%41 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.153, i64 0, i64 0))
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.154, i64 0, i64 0))
%43 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str.155, i64 0, i64 0))
%44 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @str.156, i64 0, i64 0))
%45 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.157, i64 0, i64 0))
%46 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.158, i64 0, i64 0))
%47 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([95 x i8], [95 x i8]* @str.159, i64 0, i64 0))
%48 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.160, i64 0, i64 0))
%49 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @str.161, i64 0, i64 0))
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @str.162, i64 0, i64 0))
%51 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.163, i64 0, i64 0))
%52 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.164, i64 0, i64 0))
%53 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @str.165, i64 0, i64 0))
%54 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.166, i64 0, i64 0))
%55 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([88 x i8], [88 x i8]* @str.167, i64 0, i64 0))
%56 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.177, i64 0, i64 0))
%57 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.169, i64 0, i64 0))
%58 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.170, i64 0, i64 0))
%59 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.171, i64 0, i64 0))
%60 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.172, i64 0, i64 0))
%61 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.173, i64 0, i64 0))
%62 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.174, i64 0, i64 0))
%63 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str.175, i64 0, i64 0))
%64 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.176, i64 0, i64 0))
%65 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.177, i64 0, i64 0))
%66 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @str.178, i64 0, i64 0))
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @str.179, i64 0, i64 0))
%68 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.180, i64 0, i64 0))
%69 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.181, i64 0, i64 0))
%70 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.187, i64 0, i64 0))
%71 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.183, i64 0, i64 0))
%72 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str.184, i64 0, i64 0))
%73 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str.185, i64 0, i64 0))
%74 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str.186, i64 0, i64 0))
%75 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.187, i64 0, i64 0))
%76 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.188, i64 0, i64 0))
%77 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.189, i64 0, i64 0))
%78 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @str.190, i64 0, i64 0))
%79 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.191, i64 0, i64 0))
%80 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.192, i64 0, i64 0))
%81 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.193, i64 0, i64 0))
%82 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str.194, i64 0, i64 0))
%83 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.195, i64 0, i64 0))
%84 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.196, i64 0, i64 0))
%85 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.197, i64 0, i64 0))
%86 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.198, i64 0, i64 0))
%87 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.199, i64 0, i64 0))
%88 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.200, i64 0, i64 0))
%89 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @str.201, i64 0, i64 0))
%90 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.202, i64 0, i64 0))
%91 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str.203, i64 0, i64 0))
%92 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.204, i64 0, i64 0))
%93 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str.205, i64 0, i64 0))
%94 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.206, i64 0, i64 0))
%95 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([67 x i8], [67 x i8]* @str.207, i64 0, i64 0))
%96 = tail call i32 (...) @wait_any_key()
%97 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.208, i64 0, i64 0))
%98 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.209, i64 0, i64 0))
%99 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.210, i64 0, i64 0))
%100 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.211, i64 0, i64 0))
%101 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.212, i64 0, i64 0))
%102 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.213, i64 0, i64 0))
%103 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.214, i64 0, i64 0))
%104 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.215, i64 0, i64 0))
%105 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.216, i64 0, i64 0))
%106 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.217, i64 0, i64 0))
%107 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.218, i64 0, i64 0))
%108 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.219, i64 0, i64 0))
%109 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.220, i64 0, i64 0))
%110 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.221, i64 0, i64 0))
%111 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.222, i64 0, i64 0))
%112 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.223, i64 0, i64 0))
%113 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.224, i64 0, i64 0))
%114 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.225, i64 0, i64 0))
%115 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.226, i64 0, i64 0))
%116 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.227, i64 0, i64 0))
%117 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.228, i64 0, i64 0))
%118 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @str.229, i64 0, i64 0))
ret void
}