#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*/ printf(char *, char *, char *, char *, char *, char *);
int print_help(char *v, int verbosity) {
  printf(
      "Plambda evaluates an expression with images as variables.\n"
      "\n"
      "The expression is written in reverse polish notation using common\n"
      "operators and functions from `math.h'.  The variables appearing on the\n"
      "expression are assigned to each input image in alphabetical order.\n"
      "%s"
      "\n"
      "Usage: %s a.png b.png c.png ... \"EXPRESSION\" > output\n"
      "   or: %s a.png b.png c.png ... \"EXPRESSION\" -o output.png\n"
      "   or: %s -c num1 num2 num3  ... \"EXPRESSION\"\n"
      "\n"
      "Options:\n"
      " -o file\tsave output to named file\n"
      " -c\t\tact as a symbolic calculator\n"
      " -h\t\tdisplay short help message\n"
      " --help\t\tdisplay longer help message\n"
      "\n"
      "Examples:\n"
      " plambda a.tiff b.tiff \"x y +\" > sum.tiff\tCompute the sum of two "
      "images.\n"
      " plambda -c \"1 atan 4 *\"\t\t\tPrint pi\n"
      "%s"
      "\n"
      "Report bugs to <enric.meinhardt@cmla.ens-cachan.fr>.\n",
      verbosity > 0
          ? "\n"
            "EXPRESSIONS:\n\n"
            "A \"plambda\" expression is a sequence of tokens.\nTokens may be "
            "constants,\n"
            "variables, or operators.  Constants and variables get their "
            "value\n"
            "computed and pushed to the stack.  Operators pop values from the "
            "stack,\n"
            "apply a function to them, and push back the results.\n"
            "\n"
            "CONSTANTS: numeric constants written in scientific notation, and "
            "\"pi\"\n"
            "\n"
            "OPERATORS: +, -, *, ^, /, <, >, ==, and all the functions from "
            "math.h\n"
            "\n"
            "LOGIC OPS: if, and, or, not\n"
            "\n"
            "VARIABLES: anything not recognized as a constant or operator.  "
            "There\n"
            "must be as many variables as input images, and they are assigned "
            "to\n"
            "images in alphabetical order.  If there are no variables, the "
            "input\n"
            "images are pushed to the stack.\n"
            "\n"
            "All operators (unary, binary and ternary) are vectorizable.  "
            "Thus, you can\n"
            "add a scalar to a vector, divide two vectors of the same size, "
            "and so on.\n"
            "The semantics of each operation follows the principle of least "
            "surprise.\n"
            "\n"
            "Some \"sugar\" is added to the language:\n"
            "\n"
            "Predefined variables (always preceeded by a colon):\n"
            " :i\thorizontal coordinate of the pixel\n"
            " :j\tvertical coordinate of the pixel\n"
            " :w\twidth of the image\n"
            " :h\theigth of the image\n"
            " :n\tnumber of pixels in the image\n"
            " :x\trelative horizontal coordinate of the pixel\n"
            " :y\trelative horizontal coordinate of the pixel\n"
            " :r\trelative distance to the center of the image\n"
            " :t\trelative angle from the center of the image\n"
            " :I\thorizontal coordinate of the pixel (centered)\n"
            " :J\tvertical coordinate of the pixel (centered)\n"
            " :P\thorizontal coordinate of the pixel (phased)\n"
            " :Q\tvertical coordinate of the pixel (phased)\n"
            " :R\tcentered distance to the center\n"
            " :L\tminus squared centered distance to the center\n"
            " :W\twidth of the image divided by 2*pi\n"
            " :H\theight of the image divided by 2*pi\n"
            "\n"
            "Variable modifiers acting on regular variables:\n"
            " x\t\tvalue of pixel (i,j)\n"
            " x(0,0)\t\tvalue of pixel (i,j)\n"
            " x(1,0)\t\tvalue of pixel (i+1,j)\n"
            " x(0,-1)\tvalue of pixel (i,j-1)\n"
            " x[0]\t\tvalue of first component of pixel (i,j)\n"
            " x[1]\t\tvalue of second component of pixel (i,j)\n"
            " x(1,2)[3]\tvalue of fourth component of pixel (i+1,j+2)\n"
            "Comma modifiers (pre-defined local operators):\n"
            " a,x\tx-derivative of the image a\n"
            " a,y\ty-derivative\n"
            " a,xx\tsecond x-derivative\n"
            " a,yy\tsecond y-derivative\n"
            " a,xy\tcrossed second derivative\n"
            " a,l\tLaplacian\n"
            " a,g\tgradient\n"
            " a,n\tgradient norm\n"
            " a,d\tdivergence\n"
            " a,S\tshadow operator\n"
            " a,xf\tx-derivative, forward differences\n"
            " a,xb\tx-derivative, backward differences\n"
            " a,xc\tx-derivative, centered differences\n"
            " a,xs\tx-derivative, sobel\n"
            " a,xp\tx-derivative, prewitt\n"
            " etc\n"
            "\n"
            "Stack operators (allow direct manipulation of the stack):\n"
            " del\tremove the value at the top of the stack (ATTTOS)\n"
            " dup\tduplicate the value ATTTOS\n"
            " rot\tswap the two values ATTTOS\n"
            " split\tsplit the vector ATTTOS into scalar components\n"
            " join\tjoin the components of two vectors ATTOTS\n"
            " join3\tjoin the components of three vectors ATTOTS\n"
            " njoin\tjoin the components of n vectors\n"
            " halve\tsplit an even-sized vector ATTOTS into two equal-sized "
            "parts\n"
            "\n"
            "Magic variable modifiers (global data associated to each input "
            "image):\n"
            " x%i\tvalue of the smallest sample of image x\n"
            " x%a\tvalue of the largest sample\n"
            " x%v\taverage sample value\n"
            " x%m\tmedian sample value\n"
            " x%s\tsum of all samples\n"
            " x%I\tvalue of the smallest pixel (in euclidean norm)\n"
            " x%A\tvalue of the largest pixel\n"
            " x%V\taverage pixel value\n"
            " x%S\tsum of all pixels\n"
            " x%Y\tcomponent-wise minimum of all pixels\n"
            " x%E\tcomponent-wise maximum of all pixels\n"
            " x%qn\tnth sample percentile\n"
            " x%On\tcomponent-wise nth percentile\n"
            " x%Wn\tcomponent-wise nth millionth part\n"
            " x%0n\tcomponent-wise nth order statistic\n"
            " x%9n\tcomponent-wise nth order statistic (from the right)\n"
            "\n"
            "Random numbers (seeded by the SRAND environment variable):\n"
            " randu\tpush a random number with distribution Uniform(0,1)\n"
            " randn\tpush a random number with distribution Normal(0,1)\n"
            " randc\tpush a random number with distribution Cauchy(0,1)\n"
            " randl\tpush a random number with distribution Laplace(0,1)\n"
            " rande\tpush a random number with distribution Exponential(1)\n"
            " randp\tpush a random number with distribution Pareto(1)\n"
            " rand\tpush a random integer returned from rand(3)\n"
            "\n"
            "Vectorial operations (acting over vectors of a certain length):\n"
            " topolar\tconvert a 2-vector from cartesian to polar\n"
            " frompolar\tconvert a 2-vector from polar to cartesian\n"
            " hsv2rgb\tconvert a 3-vector from HSV to RGB\n"
            " rgb2hsv\tconvert a 3-vector from RGB to HSV\n"
            " xyz2rgb\tconvert a 3-vector from XYZ to RGB\n"
            " rgb2xyz\tconvert a 3-vector from RGB to XYZ\n"
            " cprod\t\tmultiply two 2-vectrs as complex numbers\n"
            " mprod\t\tmultiply two 2-vectrs as matrices (4-vector = 2x2 "
            "matrix, etc)\n"
            " vprod\t\tvector product of two 3-vectors\n"
            " sprod\t\tscalar product of two n-vectors\n"
            " mdet\t\tdeterminant of a n-matrix (a n*n-vector)\n"
            " mtrans\t\ttranspose of a matrix\n"
            " mtrace\t\ttrace of a matrix\n"
            " minv\t\tinverse of a matrix\n"
            "\n"
            "Registers (numbered from 1 to 9):\n"
            " >7\tcopy to register 7\n"
            " <3\tcopy from register 3\n"
            "\n"
          : "See the manual page for details on the syntax for expressions.\n",
      v, v, v,
      verbosity < 1
          ? ""
          : " plambda -c \"355 113 /\"\t\t\t\tPrint an approximation of pi\n");
  return 0;
}


x86 assembly (clang, -O0):
<print_help>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%ecx
lea    0x2479(%rip),%rsi
lea    0x11be(%rip),%rax
cmp    $0x0,%ecx
cmovg  %rax,%rsi
mov    -0x8(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x8(%rbp),%r8
mov    -0xc(%rbp),%edi
lea    0x2495(%rip),%r9
lea    0x244d(%rip),%rax
cmp    $0x1,%edi
cmovl  %rax,%r9
lea    0xe9e(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_help>:
push   %rax
mov    %rdi,%rcx
test   %esi,%esi
lea    0x11d1(%rip),%rax
lea    0x247e(%rip),%rsi
cmovg  %rax,%rsi
lea    0x2472(%rip),%rax
lea    0x24ac(%rip),%r9
cmovle %rax,%r9
lea    0xebf(%rip),%rdi
mov    %rcx,%rdx
mov    %rcx,%r8
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [750 x i8] c"Plambda evaluates an expression with images as variables.\0A\0AThe expression is written in reverse polish notation using common\0Aoperators and functions from `math.h'. The variables appearing on the\0Aexpression are assigned to each input image in alphabetical order.\0A%s\0AUsage: %s a.png b.png c.png ... \22EXPRESSION\22 > output\0A or: %s a.png b.png c.png ... \22EXPRESSION\22 -o output.png\0A or: %s -c num1 num2 num3 ... \22EXPRESSION\22\0A\0AOptions:\0A -o file\09save output to named file\0A -c\09\09act as a symbolic calculator\0A -h\09\09display short help message\0A --help\09\09display longer help message\0A\0AExamples:\0A plambda a.tiff b.tiff \22x y +\22 > sum.tiff\09Compute the sum of two images.\0A plambda -c \221 atan 4 *\22\09\09\09Print pi\0A%s\0AReport bugs to <enric.meinhardt@cmla.ens-cachan.fr>.\0A\00"
@.str.1 = [4788 x i8] c"\0AEXPRESSIONS:\0A\0AA \22plambda\22 expression is a sequence of tokens.\0ATokens may be constants,\0Avariables, or operators. Constants and variables get their value\0Acomputed and pushed to the stack. Operators pop values from the stack,\0Aapply a function to them, and push back the results.\0A\0ACONSTANTS: numeric constants written in scientific notation, and \22pi\22\0A\0AOPERATORS: +, -, *, ^, /, <, >, ==, and all the functions from math.h\0A\0ALOGIC OPS: if, and, or, not\0A\0AVARIABLES: anything not recognized as a constant or operator. There\0Amust be as many variables as input images, and they are assigned to\0Aimages in alphabetical order. If there are no variables, the input\0Aimages are pushed to the stack.\0A\0AAll operators (unary, binary and ternary) are vectorizable. Thus, you can\0Aadd a scalar to a vector, divide two vectors of the same size, and so on.\0AThe semantics of each operation follows the principle of least surprise.\0A\0ASome \22sugar\22 is added to the language:\0A\0APredefined variables (always preceeded by a colon):\0A :i\09horizontal coordinate of the pixel\0A :j\09vertical coordinate of the pixel\0A :w\09width of the image\0A :h\09heigth of the image\0A :n\09number of pixels in the image\0A :x\09relative horizontal coordinate of the pixel\0A :y\09relative horizontal coordinate of the pixel\0A :r\09relative distance to the center of the image\0A :t\09relative angle from the center of the image\0A :I\09horizontal coordinate of the pixel (centered)\0A :J\09vertical coordinate of the pixel (centered)\0A :P\09horizontal coordinate of the pixel (phased)\0A :Q\09vertical coordinate of the pixel (phased)\0A :R\09centered distance to the center\0A :L\09minus squared centered distance to the center\0A :W\09width of the image divided by 2*pi\0A :H\09height of the image divided by 2*pi\0A\0AVariable modifiers acting on regular variables:\0A x\09\09value of pixel (i,j)\0A x(0,0)\09\09value of pixel (i,j)\0A x(1,0)\09\09value of pixel (i+1,j)\0A x(0,-1)\09value of pixel (i,j-1)\0A x[0]\09\09value of first component of pixel (i,j)\0A x[1]\09\09value of second component of pixel (i,j)\0A x(1,2)[3]\09value of fourth component of pixel (i+1,j+2)\0AComma modifiers (pre-defined local operators):\0A a,x\09x-derivative of the image a\0A a,y\09y-derivative\0A a,xx\09second x-derivative\0A a,yy\09second y-derivative\0A a,xy\09crossed second derivative\0A a,l\09Laplacian\0A a,g\09gradient\0A a,n\09gradient norm\0A a,d\09divergence\0A a,S\09shadow operator\0A a,xf\09x-derivative, forward differences\0A a,xb\09x-derivative, backward differences\0A a,xc\09x-derivative, centered differences\0A a,xs\09x-derivative, sobel\0A a,xp\09x-derivative, prewitt\0A etc\0A\0AStack operators (allow direct manipulation of the stack):\0A del\09remove the value at the top of the stack (ATTTOS)\0A dup\09duplicate the value ATTTOS\0A rot\09swap the two values ATTTOS\0A split\09split the vector ATTTOS into scalar components\0A join\09join the components of two vectors ATTOTS\0A join3\09join the components of three vectors ATTOTS\0A njoin\09join the components of n vectors\0A halve\09split an even-sized vector ATTOTS into two equal-sized parts\0A\0AMagic variable modifiers (global data associated to each input image):\0A x%i\09value of the smallest sample of image x\0A x%a\09value of the largest sample\0A x%v\09average sample value\0A x%m\09median sample value\0A x%s\09sum of all samples\0A x%I\09value of the smallest pixel (in euclidean norm)\0A x%A\09value of the largest pixel\0A x%V\09average pixel value\0A x%S\09sum of all pixels\0A x%Y\09component-wise minimum of all pixels\0A x%E\09component-wise maximum of all pixels\0A x%qn\09nth sample percentile\0A x%On\09component-wise nth percentile\0A x%Wn\09component-wise nth millionth part\0A x%0n\09component-wise nth order statistic\0A x%9n\09component-wise nth order statistic (from the right)\0A\0ARandom numbers (seeded by the SRAND environment variable):\0A randu\09push a random number with distribution Uniform(0,1)\0A randn\09push a random number with distribution Normal(0,1)\0A randc\09push a random number with distribution Cauchy(0,1)\0A randl\09push a random number with distribution Laplace(0,1)\0A rande\09push a random number with distribution Exponential(1)\0A randp\09push a random number with distribution Pareto(1)\0A rand\09push a random integer returned from rand(3)\0A\0AVectorial operations (acting over vectors of a certain length):\0A topolar\09convert a 2-vector from cartesian to polar\0A frompolar\09convert a 2-vector from polar to cartesian\0A hsv2rgb\09convert a 3-vector from HSV to RGB\0A rgb2hsv\09convert a 3-vector from RGB to HSV\0A xyz2rgb\09convert a 3-vector from XYZ to RGB\0A rgb2xyz\09convert a 3-vector from RGB to XYZ\0A cprod\09\09multiply two 2-vectrs as complex numbers\0A mprod\09\09multiply two 2-vectrs as matrices (4-vector = 2x2 matrix, etc)\0A vprod\09\09vector product of two 3-vectors\0A sprod\09\09scalar product of two n-vectors\0A mdet\09\09determinant of a n-matrix (a n*n-vector)\0A mtrans\09\09transpose of a matrix\0A mtrace\09\09trace of a matrix\0A minv\09\09inverse of a matrix\0A\0ARegisters (numbered from 1 to 9):\0A >7\09copy to register 7\0A <3\09copy from register 3\0A\0A\00"
@.str.2 = [64 x i8] c"See the manual page for details on the syntax for expressions.\0A\00"
@.str.3 = [1 x i8] zeroinitializer
@.str.4 = [57 x i8] c" plambda -c \22355 113 /\22\09\09\09\09Print an approximation of pi\0A\00"
define i32 @print_help(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
%5 = load i32, i32* %4
%6 = icmp sgt i32 %5, 0
%7 = zext i1 %6 to i64
%8 = select i1 %6, i8* getelementptr inbounds ([4788 x i8], [4788 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.2, i64 0, i64 0)
%9 = load i8*, i8** %3
%10 = load i8*, i8** %3
%11 = load i8*, i8** %3
%12 = load i32, i32* %4
%13 = icmp slt i32 %12, 1
%14 = zext i1 %13 to i64
%15 = select i1 %13, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0)
%16 = call i32 @printf(i8* getelementptr inbounds ([750 x i8], [750 x i8]* @.str, i64 0, i64 0), i8* %8, i8* %9, i8* %10, i8* %11, i8* %15)
ret i32 0
}

LLVM IR (-O2):
@.str = [750 x i8] c"Plambda evaluates an expression with images as variables.\0A\0AThe expression is written in reverse polish notation using common\0Aoperators and functions from `math.h'. The variables appearing on the\0Aexpression are assigned to each input image in alphabetical order.\0A%s\0AUsage: %s a.png b.png c.png ... \22EXPRESSION\22 > output\0A or: %s a.png b.png c.png ... \22EXPRESSION\22 -o output.png\0A or: %s -c num1 num2 num3 ... \22EXPRESSION\22\0A\0AOptions:\0A -o file\09save output to named file\0A -c\09\09act as a symbolic calculator\0A -h\09\09display short help message\0A --help\09\09display longer help message\0A\0AExamples:\0A plambda a.tiff b.tiff \22x y +\22 > sum.tiff\09Compute the sum of two images.\0A plambda -c \221 atan 4 *\22\09\09\09Print pi\0A%s\0AReport bugs to <enric.meinhardt@cmla.ens-cachan.fr>.\0A\00"
@.str.1 = [4788 x i8] c"\0AEXPRESSIONS:\0A\0AA \22plambda\22 expression is a sequence of tokens.\0ATokens may be constants,\0Avariables, or operators. Constants and variables get their value\0Acomputed and pushed to the stack. Operators pop values from the stack,\0Aapply a function to them, and push back the results.\0A\0ACONSTANTS: numeric constants written in scientific notation, and \22pi\22\0A\0AOPERATORS: +, -, *, ^, /, <, >, ==, and all the functions from math.h\0A\0ALOGIC OPS: if, and, or, not\0A\0AVARIABLES: anything not recognized as a constant or operator. There\0Amust be as many variables as input images, and they are assigned to\0Aimages in alphabetical order. If there are no variables, the input\0Aimages are pushed to the stack.\0A\0AAll operators (unary, binary and ternary) are vectorizable. Thus, you can\0Aadd a scalar to a vector, divide two vectors of the same size, and so on.\0AThe semantics of each operation follows the principle of least surprise.\0A\0ASome \22sugar\22 is added to the language:\0A\0APredefined variables (always preceeded by a colon):\0A :i\09horizontal coordinate of the pixel\0A :j\09vertical coordinate of the pixel\0A :w\09width of the image\0A :h\09heigth of the image\0A :n\09number of pixels in the image\0A :x\09relative horizontal coordinate of the pixel\0A :y\09relative horizontal coordinate of the pixel\0A :r\09relative distance to the center of the image\0A :t\09relative angle from the center of the image\0A :I\09horizontal coordinate of the pixel (centered)\0A :J\09vertical coordinate of the pixel (centered)\0A :P\09horizontal coordinate of the pixel (phased)\0A :Q\09vertical coordinate of the pixel (phased)\0A :R\09centered distance to the center\0A :L\09minus squared centered distance to the center\0A :W\09width of the image divided by 2*pi\0A :H\09height of the image divided by 2*pi\0A\0AVariable modifiers acting on regular variables:\0A x\09\09value of pixel (i,j)\0A x(0,0)\09\09value of pixel (i,j)\0A x(1,0)\09\09value of pixel (i+1,j)\0A x(0,-1)\09value of pixel (i,j-1)\0A x[0]\09\09value of first component of pixel (i,j)\0A x[1]\09\09value of second component of pixel (i,j)\0A x(1,2)[3]\09value of fourth component of pixel (i+1,j+2)\0AComma modifiers (pre-defined local operators):\0A a,x\09x-derivative of the image a\0A a,y\09y-derivative\0A a,xx\09second x-derivative\0A a,yy\09second y-derivative\0A a,xy\09crossed second derivative\0A a,l\09Laplacian\0A a,g\09gradient\0A a,n\09gradient norm\0A a,d\09divergence\0A a,S\09shadow operator\0A a,xf\09x-derivative, forward differences\0A a,xb\09x-derivative, backward differences\0A a,xc\09x-derivative, centered differences\0A a,xs\09x-derivative, sobel\0A a,xp\09x-derivative, prewitt\0A etc\0A\0AStack operators (allow direct manipulation of the stack):\0A del\09remove the value at the top of the stack (ATTTOS)\0A dup\09duplicate the value ATTTOS\0A rot\09swap the two values ATTTOS\0A split\09split the vector ATTTOS into scalar components\0A join\09join the components of two vectors ATTOTS\0A join3\09join the components of three vectors ATTOTS\0A njoin\09join the components of n vectors\0A halve\09split an even-sized vector ATTOTS into two equal-sized parts\0A\0AMagic variable modifiers (global data associated to each input image):\0A x%i\09value of the smallest sample of image x\0A x%a\09value of the largest sample\0A x%v\09average sample value\0A x%m\09median sample value\0A x%s\09sum of all samples\0A x%I\09value of the smallest pixel (in euclidean norm)\0A x%A\09value of the largest pixel\0A x%V\09average pixel value\0A x%S\09sum of all pixels\0A x%Y\09component-wise minimum of all pixels\0A x%E\09component-wise maximum of all pixels\0A x%qn\09nth sample percentile\0A x%On\09component-wise nth percentile\0A x%Wn\09component-wise nth millionth part\0A x%0n\09component-wise nth order statistic\0A x%9n\09component-wise nth order statistic (from the right)\0A\0ARandom numbers (seeded by the SRAND environment variable):\0A randu\09push a random number with distribution Uniform(0,1)\0A randn\09push a random number with distribution Normal(0,1)\0A randc\09push a random number with distribution Cauchy(0,1)\0A randl\09push a random number with distribution Laplace(0,1)\0A rande\09push a random number with distribution Exponential(1)\0A randp\09push a random number with distribution Pareto(1)\0A rand\09push a random integer returned from rand(3)\0A\0AVectorial operations (acting over vectors of a certain length):\0A topolar\09convert a 2-vector from cartesian to polar\0A frompolar\09convert a 2-vector from polar to cartesian\0A hsv2rgb\09convert a 3-vector from HSV to RGB\0A rgb2hsv\09convert a 3-vector from RGB to HSV\0A xyz2rgb\09convert a 3-vector from XYZ to RGB\0A rgb2xyz\09convert a 3-vector from RGB to XYZ\0A cprod\09\09multiply two 2-vectrs as complex numbers\0A mprod\09\09multiply two 2-vectrs as matrices (4-vector = 2x2 matrix, etc)\0A vprod\09\09vector product of two 3-vectors\0A sprod\09\09scalar product of two n-vectors\0A mdet\09\09determinant of a n-matrix (a n*n-vector)\0A mtrans\09\09transpose of a matrix\0A mtrace\09\09trace of a matrix\0A minv\09\09inverse of a matrix\0A\0ARegisters (numbered from 1 to 9):\0A >7\09copy to register 7\0A <3\09copy from register 3\0A\0A\00"
@.str.2 = [64 x i8] c"See the manual page for details on the syntax for expressions.\0A\00"
@.str.3 = [1 x i8] zeroinitializer
@.str.4 = [57 x i8] c" plambda -c \22355 113 /\22\09\09\09\09Print an approximation of pi\0A\00"
define i32 @print_help(i8* %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
%4 = select i1 %3, i8* getelementptr inbounds ([4788 x i8], [4788 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.2, i64 0, i64 0)
%5 = icmp slt i32 %1, 1
%6 = select i1 %5, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0)
%7 = tail call i32 @printf(i8* getelementptr inbounds ([750 x i8], [750 x i8]* @.str, i64 0, i64 0), i8* %4, i8* %0, i8* %0, i8* %0, i8* %6)
ret i32 0
}