#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
void usage(void) {
  fprintf(stderr, "USAGE:\n");
  fprintf(stderr, "so -i <SKID .gtp file> [-o <outfilebase>] [([-dark] [-gas] "
                  "[-star]) || [-all])]\n");
  fprintf(stderr, "      [-mark <markfile>]  [-std]  [-grp] [-gtp] [-subsumed] "
                  "[-ignored]\n");
  fprintf(stderr, "      [-list <File containing group indexes>]\n");
  fprintf(stderr, "      [-pot || -stat <SKID .stat file containing "
                  "most-bound-particle positions>]\n");
  fprintf(
      stderr,
      "      [-delta <fThreshold>] [-M <fMinGTPMass>] [-m <mMinSOMembers>]\n");
  fprintf(stderr, "      [-O <fOmega0>]  [-L]  [-z <fRedshift>]\n");
  fprintf(stderr, "      [-p <xyzPeriod>]  [-c <xyzCenter>]\n");
  fprintf(stderr, "      [-cx <xCenter>]  [-cy <yCenter>]  [-cz <zCenter>]\n");
  fprintf(stderr, "      [-u <fMassUnit> <fMpcUnit>]\n\n");
  fprintf(stderr, "  Finds smallest spherical radius R within which the "
                  "density is less than\n");
  fprintf(stderr, "  the value <fThreshold> and calculates enclosed mass, half "
                  "mass and quarter\n");
  fprintf(stderr, "  mass radii, maximum circular velocity and max Vcirc "
                  "radius, as well as\n");
  fprintf(stderr, "  Vcirc in 1/4R increments from 1/4R to 2R.\n");
  fprintf(
      stderr,
      "   -o: Main output will be written to file <outfilebase>.sovcirc.\n");
  fprintf(stderr, "       default = so.sovcirc.\n");
  fprintf(stderr, "   -dark -gas -star: Outputs radial profile of dark, gas, "
                  "and/or star particles\n");
  fprintf(
      stderr,
      "       in a separate file <outfilebase>.sodark / .sogas / .sostar\n");
  fprintf(stderr, "   -all: same as '-dark -gas -star'.\n");
  fprintf(stderr, "   -mark: Outputs radial profile of marked particles given "
                  "in <markfile> to\n");
  fprintf(stderr, "       to a separate file <outfilebase>.somark.\n");
  fprintf(stderr, "   -std: Read and write standard TIPSY binaries.\n");
  fprintf(stderr, "   -grp -gtp: Causes .sogrp and/or .sogtp file to be "
                  "written.  The group\n");
  fprintf(stderr, "       numbers given in these output files are the SAME as "
                  "the group numbers\n");
  fprintf(stderr, "       in the input .gtp file.  Groups in the .sogtp file "
                  "that are not examined\n");
  fprintf(stderr, "       at all will have 0 mass and 0 radius.  Groups for "
                  "which SO tries and\n");
  fprintf(stderr, "       fails to find radius R will have mass 0 and "
                  "'-errorcode' radius.\n");
  fprintf(stderr, "   -pot: Center on the most bound particle of the group.  "
                  "Default is to center\n");
  fprintf(stderr, "       on the group position as given in the input .gtp "
                  "file.  In this case,\n");
  fprintf(stderr, "       the most bound particle is the particle within the "
                  "radius of the input\n");
  fprintf(stderr, "       groups that has the smallest Phi field given in the "
                  "TIPSY file.\n");
  fprintf(stderr, "   -stat: Center on the most bound particle as reported by "
                  "the SKID .stat file.\n");
  fprintf(stderr, "       This method is preferable to to -pot as SKID "
                  "constructs potentials from\n");
  fprintf(stderr, "       only those particles in the group and is not subject "
                  "to the global\n");
  fprintf(stderr, "       potential field.  NOTE: this requires SKID revisions "
                  "from 2/25/00.\n");
  fprintf(stderr, "   -delta: By default, <fThreshold> is calculated "
                  "automatically from cosmological\n");
  fprintf(stderr, "       parameters to be the virial density, but may be "
                  "overridden using the\n");
  fprintf(
      stderr,
      "       -delta option by specifying the overdensity of the threshold.\n");
  fprintf(stderr, "   -L: option will set Lambda0 = 1-Omega0.\n");
  fprintf(stderr, "   -p: THIS VERSION ASSUMES PERIODIC BOUNDRY CONDITIONS.  "
                  "Default period = 1\n");
  fprintf(stderr, "   -z: <fRedshift> will be automatically calculated as "
                  "1/h.time-1 where h.time\n");
  fprintf(stderr, "       is read from the TIPSY particle file header.  -z "
                  "will override this.\n");
  fprintf(stderr, "   -M: <fMinGTPMass> specifies the minimum mass a group "
                  "given in the input .gtp\n");
  fprintf(stderr, "        file must have in order to be considered.\n");
  fprintf(stderr, "   -list: names an ASCII file which lists indexes of groups "
                  "in the input .gtp\n");
  fprintf(stderr, "        file to be considered.  This may be used in "
                  "conjunction with -M.\n");
  fprintf(stderr, "   -m: <fMinSOMembers> specifies the minimum number of "
                  "particles a group must\n");
  fprintf(stderr,
          "       have for its parameters to be accurately calculated.\n");
  fprintf(stderr, "   -u: Output is in system units unless simulation units "
                  "are specified with -u\n");
  fprintf(stderr, "       option, whereupon output will be in the form:\n");
  fprintf(stderr, "       Mass [Msol], Distance [kpc], Velocity [km/s].\n");
  fprintf(stderr, "   -subsumed/-ignored: causes .sosub/.soign TIPSY array "
                  "files to be written\n");
  fprintf(stderr, "       which give the number of times a particle was "
                  "subsumed into a larger\n");
  fprintf(stderr, "       group or ignored by a larger group because it "
                  "belonged to a smaller one.\n");
  fprintf(stderr, "\n  See output file header for output format.\n\n");
  fprintf(stderr, "  Groupwise error codes are returned in Mvir and Rvir "
                  "columns as follows:\n");
  fprintf(stderr, "     -1.0:  Fewer than nMembers particles within 1.2 times "
                  "group's .grp radius\n");
  fprintf(stderr, "     -2.0:  Density < <fThreshold> within radius enclosing "
                  "no more than\n");
  fprintf(stderr, "            <nMembers> particles.\n");
  fprintf(stderr, "     -3.0:  Density > <fThreshold> beyond 3 times group's "
                  ".grp radius\n");
  fprintf(stderr, "     -Mvir: Group was 'subsumed' or 'slurped' by the group "
                  "'groupID' that is given\n");
  fprintf(stderr, "            in the Rvir columns as -10*groupID.  If the Vc "
                  "columns are set with\n");
  fprintf(stderr, "            meaningful numbers, then it was 'subsumed'.  If "
                  "the numbers are 0,\n");
  fprintf(stderr, "            then it was 'slurped'.\n");
  fprintf(stderr, "\n'Subsuming,' 'Slurping,' and 'Retaining' behavior:\n");
  fprintf(stderr, "    The groups are SO'd in increasing order of SKID or FOF "
                  "mass.  This is an attempt\n");
  fprintf(stderr, "    to produce the results whereby the most massive SO "
                  "groups take precidence over\n");
  fprintf(stderr, "    the smaller SO groups during a group collision.  After "
                  "SO finds the virial mass\n");
  fprintf(stderr, "    and radius of group 'A', it examines the member "
                  "particles of A to see if any of them\n");
  fprintf(stderr, "    are members of other groups.  When it encounters a "
                  "particle that is already a member\n");
  fprintf(stderr, "    of another group 'B' it checks as follows:\n");
  fprintf(stderr,
          "        1. If the center of B is within the virial radius of A:\n");
  fprintf(stderr,
          "                - Zero all particles that were members of B.\n");
  fprintf(stderr, "                - Mark Mvir and Rvir of B according to case "
                  "4 (-Mvir:) above.\n");
  fprintf(stderr, "                - Tag all particles in the virial radius of "
                  "A as belonging to A.\n");
  fprintf(stderr, "                - Group B is now 'subsumed'.\n");
  fprintf(
      stderr,
      "        2. ELSE If the center of A is within the virial radius of B:\n");
  fprintf(stderr,
          "                - Zero all particles that were members of A.\n");
  fprintf(stderr, "                - Mark Mvir and Rvir of A according to case "
                  "4 (-Mvir:) above.\n");
  fprintf(stderr, "                - Tag all particles in the virial radius of "
                  "B as belonging to B.\n");
  fprintf(stderr, "                - Group A is now 'slurped' by B.  Thus, "
                  "slurping is an odd case where\n");
  fprintf(stderr, "                  the Rvir of the smaller SKID or FOF group "
                  "is *larger* than the\n");
  fprintf(stderr, "                  Rvir of the larger SKID or FOF group.\n");
  fprintf(stderr, "                - Particles in Group A will be tabulated as "
                  "'subsumed' even though the\n");
  fprintf(stderr,
          "                  group itself will be tabulated as 'slurped.'\n");
  fprintf(stderr,
          "        2. ELSE Niether A nor B are within each other's radius:\n");
  fprintf(stderr, "                - Group B retains all of its particles.\n");
  fprintf(stderr, "                - However, all of the particles that fall "
                  "within Rvir of A,\n");
  fprintf(stderr, "                  regardless of membership, are used in "
                  "calculating group A's\n");
  fprintf(stderr, "                  quantities.  Thus, there will be a "
                  "discrepancy in the total mass\n");
  fprintf(stderr, "                  of all groups and the total mass of all "
                  "particles in groups.\n");
  fprintf(stderr, "                  This discrepancy is reported at the end "
                  "of the run.\n");
  fprintf(stderr, "                - Group B particles that would have "
                  "belonged to Group A are reported\n");
  fprintf(stderr, "                  as having been 'retained in the face of "
                  "adversity.'\n\n");
  exit(1);
}


x86 assembly (clang, -O0):
<usage>:
push   %rbp
mov    %rsp,%rbp
mov    0x3eb5(%rip),%rax
mov    (%rax),%edi
lea    0xecc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ea0(%rip),%rax
mov    (%rax),%edi
lea    0xebf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e8b(%rip),%rax
mov    (%rax),%edi
lea    0xefb(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e76(%rip),%rax
mov    (%rax),%edi
lea    0xf2e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e61(%rip),%rax
mov    (%rax),%edi
lea    0xf48(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e4c(%rip),%rax
mov    (%rax),%edi
lea    0xf85(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e37(%rip),%rax
mov    (%rax),%edi
lea    0xfb5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e22(%rip),%rax
mov    (%rax),%edi
lea    0xfce(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e0d(%rip),%rax
mov    (%rax),%edi
lea    0xfe3(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3df8(%rip),%rax
mov    (%rax),%edi
lea    0x1007(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3de3(%rip),%rax
mov    (%rax),%edi
lea    0x1016(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3dce(%rip),%rax
mov    (%rax),%edi
lea    0x104c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3db9(%rip),%rax
mov    (%rax),%edi
lea    0x1085(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3da4(%rip),%rax
mov    (%rax),%edi
lea    0x10ba(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d8f(%rip),%rax
mov    (%rax),%edi
lea    0x10d2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d7a(%rip),%rax
mov    (%rax),%edi
lea    0x1100(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d65(%rip),%rax
mov    (%rax),%edi
lea    0x1109(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d50(%rip),%rax
mov    (%rax),%edi
lea    0x1145(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d3b(%rip),%rax
mov    (%rax),%edi
lea    0x1173(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d26(%rip),%rax
mov    (%rax),%edi
lea    0x1184(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d11(%rip),%rax
mov    (%rax),%edi
lea    0x11bc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cfc(%rip),%rax
mov    (%rax),%edi
lea    0x11d8(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ce7(%rip),%rax
mov    (%rax),%edi
lea    0x11f5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cd2(%rip),%rax
mov    (%rax),%edi
lea    0x122a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cbd(%rip),%rax
mov    (%rax),%edi
lea    0x1263(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ca8(%rip),%rax
mov    (%rax),%edi
lea    0x129f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c93(%rip),%rax
mov    (%rax),%edi
lea    0x12d7(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c7e(%rip),%rax
mov    (%rax),%edi
lea    0x130b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c69(%rip),%rax
mov    (%rax),%edi
lea    0x1346(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c54(%rip),%rax
mov    (%rax),%edi
lea    0x137f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c3f(%rip),%rax
mov    (%rax),%edi
lea    0x13b9(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c2a(%rip),%rax
mov    (%rax),%edi
lea    0x13ec(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c15(%rip),%rax
mov    (%rax),%edi
lea    0x1428(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c00(%rip),%rax
mov    (%rax),%edi
lea    0x1463(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3beb(%rip),%rax
mov    (%rax),%edi
lea    0x1499(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bd6(%rip),%rax
mov    (%rax),%edi
lea    0x14cf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bc1(%rip),%rax
mov    (%rax),%edi
lea    0x150d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bac(%rip),%rax
mov    (%rax),%edi
lea    0x1545(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b97(%rip),%rax
mov    (%rax),%edi
lea    0x1576(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b82(%rip),%rax
mov    (%rax),%edi
lea    0x158d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b6d(%rip),%rax
mov    (%rax),%edi
lea    0x15c6(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b58(%rip),%rax
mov    (%rax),%edi
lea    0x1601(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b43(%rip),%rax
mov    (%rax),%edi
lea    0x1639(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b2e(%rip),%rax
mov    (%rax),%edi
lea    0x1675(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b19(%rip),%rax
mov    (%rax),%edi
lea    0x1693(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b04(%rip),%rax
mov    (%rax),%edi
lea    0x16cd(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aef(%rip),%rax
mov    (%rax),%edi
lea    0x1702(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ada(%rip),%rax
mov    (%rax),%edi
lea    0x173c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ac5(%rip),%rax
mov    (%rax),%edi
lea    0x1764(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ab0(%rip),%rax
mov    (%rax),%edi
lea    0x179f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a9b(%rip),%rax
mov    (%rax),%edi
lea    0x17c0(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a86(%rip),%rax
mov    (%rax),%edi
lea    0x17e1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a71(%rip),%rax
mov    (%rax),%edi
lea    0x1819(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a5c(%rip),%rax
mov    (%rax),%edi
lea    0x1851(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a47(%rip),%rax
mov    (%rax),%edi
lea    0x188d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a32(%rip),%rax
mov    (%rax),%edi
lea    0x18a7(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a1d(%rip),%rax
mov    (%rax),%edi
lea    0x18dd(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a08(%rip),%rax
mov    (%rax),%edi
lea    0x1918(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39f3(%rip),%rax
mov    (%rax),%edi
lea    0x194c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39de(%rip),%rax
mov    (%rax),%edi
lea    0x195a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39c9(%rip),%rax
mov    (%rax),%edi
lea    0x198c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39b4(%rip),%rax
mov    (%rax),%edi
lea    0x19cb(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x399f(%rip),%rax
mov    (%rax),%edi
lea    0x1a07(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x398a(%rip),%rax
mov    (%rax),%edi
lea    0x1a42(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3975(%rip),%rax
mov    (%rax),%edi
lea    0x1a51(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3960(%rip),%rax
mov    (%rax),%edi
lea    0x1a71(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x394b(%rip),%rax
mov    (%rax),%edi
lea    0x1ab2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3936(%rip),%rax
mov    (%rax),%edi
lea    0x1af1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3921(%rip),%rax
mov    (%rax),%edi
lea    0x1b31(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x390c(%rip),%rax
mov    (%rax),%edi
lea    0x1b76(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38f7(%rip),%rax
mov    (%rax),%edi
lea    0x1bbb(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38e2(%rip),%rax
mov    (%rax),%edi
lea    0x1bd6(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38cd(%rip),%rax
mov    (%rax),%edi
lea    0x1c02(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38b8(%rip),%rax
mov    (%rax),%edi
lea    0x1c2b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38a3(%rip),%rax
mov    (%rax),%edi
lea    0x1c65(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x388e(%rip),%rax
mov    (%rax),%edi
lea    0x1ca2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3879(%rip),%rax
mov    (%rax),%edi
lea    0x1cbb(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3864(%rip),%rax
mov    (%rax),%edi
lea    0x1cec(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x384f(%rip),%rax
mov    (%rax),%edi
lea    0x1d15(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x383a(%rip),%rax
mov    (%rax),%edi
lea    0x1d4f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3825(%rip),%rax
mov    (%rax),%edi
lea    0x1d8c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3810(%rip),%rax
mov    (%rax),%edi
lea    0x1dce(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37fb(%rip),%rax
mov    (%rax),%edi
lea    0x1e0b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37e6(%rip),%rax
mov    (%rax),%edi
lea    0x1e2f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37d1(%rip),%rax
mov    (%rax),%edi
lea    0x1e72(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37bc(%rip),%rax
mov    (%rax),%edi
lea    0x1e9d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37a7(%rip),%rax
mov    (%rax),%edi
lea    0x1ec9(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3792(%rip),%rax
mov    (%rax),%edi
lea    0x1eed(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x377d(%rip),%rax
mov    (%rax),%edi
lea    0x1f25(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3768(%rip),%rax
mov    (%rax),%edi
lea    0x1f5f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3753(%rip),%rax
mov    (%rax),%edi
lea    0x1f9e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x373e(%rip),%rax
mov    (%rax),%edi
lea    0x1fd9(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3729(%rip),%rax
mov    (%rax),%edi
lea    0x200b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3714(%rip),%rax
mov    (%rax),%edi
lea    0x204c(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<usage>:
push   %rbx
mov    0x3eb8(%rip),%rbx
mov    (%rbx),%edi
lea    0xecf(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xec9(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf0c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf46(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf67(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfab(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfe2(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1002(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x101e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1049(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x105f(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x109c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10dc(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1118(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1137(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x116c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x117c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11bf(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11f4(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x120c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x124b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x126e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1292(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12ce(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x130e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1351(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1390(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13cb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x140d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x144d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x148e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14c8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x150b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x154d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x158a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x15c7(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x160c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x164b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1683(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16a1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16e1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1723(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1762(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x17a5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x17ca(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x180b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1847(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1888(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18b7(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18f9(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1921(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1949(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1988(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x19c7(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a0a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a2b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a68(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1aaa(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1ae5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1afa(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b33(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b79(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1bbc(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1bfe(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c14(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c3b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c83(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1cc9(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1d10(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1d5c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1da8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1dca(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1dfd(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1e2d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1e6e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1eb2(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1ed2(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f0a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f3a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f7b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fbf(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2008(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x204c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2077(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x20c1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x20f3(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2126(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2151(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2190(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x21d1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2217(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2259(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2292(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x22da(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [8 x i8] c"USAGE:\0A\00"
@.str.1 = [81 x i8] c"so -i <SKID .gtp file> [-o <outfilebase>] [([-dark] [-gas] [-star]) || [-all])]\0A\00"
@.str.2 = [72 x i8] c" [-mark <markfile>] [-std] [-grp] [-gtp] [-subsumed] [-ignored]\0A\00"
@.str.3 = [47 x i8] c" [-list <File containing group indexes>]\0A\00"
@.str.4 = [82 x i8] c" [-pot || -stat <SKID .stat file containing most-bound-particle positions>]\0A\00"
@.str.5 = [69 x i8] c" [-delta <fThreshold>] [-M <fMinGTPMass>] [-m <mMinSOMembers>]\0A\00"
@.str.6 = [46 x i8] c" [-O <fOmega0>] [-L] [-z <fRedshift>]\0A\00"
@.str.7 = [42 x i8] c" [-p <xyzPeriod>] [-c <xyzCenter>]\0A\00"
@.str.8 = [57 x i8] c" [-cx <xCenter>] [-cy <yCenter>] [-cz <zCenter>]\0A\00"
@.str.9 = [36 x i8] c" [-u <fMassUnit> <fMpcUnit>]\0A\0A\00"
@.str.10 = [75 x i8] c" Finds smallest spherical radius R within which the density is less than\0A\00"
@.str.11 = [78 x i8] c" the value <fThreshold> and calculates enclosed mass, half mass and quarter\0A\00"
@.str.12 = [74 x i8] c" mass radii, maximum circular velocity and max Vcirc radius, as well as\0A\00"
@.str.13 = [45 x i8] c" Vcirc in 1/4R increments from 1/4R to 2R.\0A\00"
@.str.14 = [67 x i8] c" -o: Main output will be written to file <outfilebase>.sovcirc.\0A\00"
@.str.15 = [30 x i8] c" default = so.sovcirc.\0A\00"
@.str.16 = [81 x i8] c" -dark -gas -star: Outputs radial profile of dark, gas, and/or star particles\0A\00"
@.str.17 = [67 x i8] c" in a separate file <outfilebase>.sodark / .sogas / .sostar\0A\00"
@.str.18 = [38 x i8] c" -all: same as '-dark -gas -star'.\0A\00"
@.str.19 = [77 x i8] c" -mark: Outputs radial profile of marked particles given in <markfile> to\0A\00"
@.str.20 = [49 x i8] c" to a separate file <outfilebase>.somark.\0A\00"
@.str.21 = [50 x i8] c" -std: Read and write standard TIPSY binaries.\0A\00"
@.str.22 = [74 x i8] c" -grp -gtp: Causes .sogrp and/or .sogtp file to be written. The group\0A\00"
@.str.23 = [78 x i8] c" numbers given in these output files are the SAME as the group numbers\0A\00"
@.str.24 = [81 x i8] c" in the input .gtp file. Groups in the .sogtp file that are not examined\0A\00"
@.str.25 = [77 x i8] c" at all will have 0 mass and 0 radius. Groups for which SO tries and\0A\00"
@.str.26 = [73 x i8] c" fails to find radius R will have mass 0 and '-errorcode' radius.\0A\00"
@.str.27 = [80 x i8] c" -pot: Center on the most bound particle of the group. Default is to center\0A\00"
@.str.28 = [78 x i8] c" on the group position as given in the input .gtp file. In this case,\0A\00"
@.str.29 = [79 x i8] c" the most bound particle is the particle within the radius of the input\0A\00"
@.str.30 = [72 x i8] c" groups that has the smallest Phi field given in the TIPSY file.\0A\00"
@.str.31 = [81 x i8] c" -stat: Center on the most bound particle as reported by the SKID .stat file.\0A\00"
@.str.32 = [80 x i8] c" This method is preferable to to -pot as SKID constructs potentials from\0A\00"
@.str.33 = [75 x i8] c" only those particles in the group and is not subject to the global\0A\00"
@.str.34 = [75 x i8] c" potential field. NOTE: this requires SKID revisions from 2/25/00.\0A\00"
@.str.35 = [83 x i8] c" -delta: By default, <fThreshold> is calculated automatically from cosmological\0A\00"
@.str.36 = [77 x i8] c" parameters to be the virial density, but may be overridden using the\0A\00"
@.str.37 = [70 x i8] c" -delta option by specifying the overdensity of the threshold.\0A\00"
@.str.38 = [44 x i8] c" -L: option will set Lambda0 = 1-Omega0.\0A\00"
@.str.39 = [78 x i8] c" -p: THIS VERSION ASSUMES PERIODIC BOUNDRY CONDITIONS. Default period = 1\0A\00"
@.str.40 = [80 x i8] c" -z: <fRedshift> will be automatically calculated as 1/h.time-1 where h.time\0A\00"
@.str.41 = [77 x i8] c" is read from the TIPSY particle file header. -z will override this.\0A\00"
@.str.42 = [81 x i8] c" -M: <fMinGTPMass> specifies the minimum mass a group given in the input .gtp\0A\00"
@.str.43 = [51 x i8] c" file must have in order to be considered.\0A\00"
@.str.44 = [79 x i8] c" -list: names an ASCII file which lists indexes of groups in the input .gtp\0A\00"
@.str.45 = [74 x i8] c" file to be considered. This may be used in conjunction with -M.\0A\00"
@.str.46 = [79 x i8] c" -m: <fMinSOMembers> specifies the minimum number of particles a group must\0A\00"
@.str.47 = [61 x i8] c" have for its parameters to be accurately calculated.\0A\00"
@.str.48 = [80 x i8] c" -u: Output is in system units unless simulation units are specified with -u\0A\00"
@.str.49 = [54 x i8] c" option, whereupon output will be in the form:\0A\00"
@.str.50 = [54 x i8] c" Mass [Msol], Distance [kpc], Velocity [km/s].\0A\00"
@.str.51 = [77 x i8] c" -subsumed/-ignored: causes .sosub/.soign TIPSY array files to be written\0A\00"
@.str.52 = [77 x i8] c" which give the number of times a particle was subsumed into a larger\0A\00"
@.str.53 = [81 x i8] c" group or ignored by a larger group because it belonged to a smaller one.\0A\00"
@.str.54 = [47 x i8] c"\0A See output file header for output format.\0A\0A\00"
@.str.55 = [75 x i8] c" Groupwise error codes are returned in Mvir and Rvir columns as follows:\0A\00"
@.str.56 = [80 x i8] c" -1.0: Fewer than nMembers particles within 1.2 times group's .grp radius\0A\00"
@.str.57 = [73 x i8] c" -2.0: Density < <fThreshold> within radius enclosing no more than\0A\00"
@.str.58 = [35 x i8] c" <nMembers> particles.\0A\00"
@.str.59 = [71 x i8] c" -3.0: Density > <fThreshold> beyond 3 times group's .grp radius\0A\00"
@.str.60 = [84 x i8] c" -Mvir: Group was 'subsumed' or 'slurped' by the group 'groupID' that is given\0A\00"
@.str.61 = [81 x i8] c" in the Rvir columns as -10*groupID. If the Vc columns are set with\0A\00"
@.str.62 = [80 x i8] c" meaningful numbers, then it was 'subsumed'. If the numbers are 0,\0A\00"
@.str.63 = [36 x i8] c" then it was 'slurped'.\0A\00"
@.str.64 = [53 x i8] c"\0A'Subsuming,' 'Slurping,' and 'Retaining' behavior:\0A\00"
@.str.65 = [86 x i8] c" The groups are SO'd in increasing order of SKID or FOF mass. This is an attempt\0A\00"
@.str.66 = [84 x i8] c" to produce the results whereby the most massive SO groups take precidence over\0A\00"
@.str.67 = [85 x i8] c" the smaller SO groups during a group collision. After SO finds the virial mass\0A\00"
@.str.68 = [90 x i8] c" and radius of group 'A', it examines the member particles of A to see if any of them\0A\00"
@.str.69 = [90 x i8] c" are members of other groups. When it encounters a particle that is already a member\0A\00"
@.str.70 = [48 x i8] c" of another group 'B' it checks as follows:\0A\00"
@.str.71 = [65 x i8] c" 1. If the center of B is within the virial radius of A:\0A\00"
@.str.72 = [62 x i8] c" - Zero all particles that were members of B.\0A\00"
@.str.73 = [79 x i8] c" - Mark Mvir and Rvir of B according to case 4 (-Mvir:) above.\0A\00"
@.str.74 = [82 x i8] c" - Tag all particles in the virial radius of A as belonging to A.\0A\00"
@.str.75 = [46 x i8] c" - Group B is now 'subsumed'.\0A\00"
@.str.76 = [70 x i8] c" 2. ELSE If the center of A is within the virial radius of B:\0A\00"
@.str.77 = [62 x i8] c" - Zero all particles that were members of A.\0A\00"
@.str.78 = [79 x i8] c" - Mark Mvir and Rvir of A according to case 4 (-Mvir:) above.\0A\00"
@.str.79 = [82 x i8] c" - Tag all particles in the virial radius of B as belonging to B.\0A\00"
@.str.80 = [87 x i8] c" - Group A is now 'slurped' by B. Thus, slurping is an odd case where\0A\00"
@.str.81 = [82 x i8] c" the Rvir of the smaller SKID or FOF group is *larger* than the\0A\00"
@.str.82 = [57 x i8] c" Rvir of the larger SKID or FOF group.\0A\00"
@.str.83 = [88 x i8] c" - Particles in Group A will be tabulated as 'subsumed' even though the\0A\00"
@.str.84 = [64 x i8] c" group itself will be tabulated as 'slurped.'\0A\00"
@.str.85 = [65 x i8] c" 2. ELSE Niether A nor B are within each other's radius:\0A\00"
@.str.86 = [57 x i8] c" - Group B retains all of its particles.\0A\00"
@.str.87 = [77 x i8] c" - However, all of the particles that fall within Rvir of A,\0A\00"
@.str.88 = [79 x i8] c" regardless of membership, are used in calculating group A's\0A\00"
@.str.89 = [84 x i8] c" quantities. Thus, there will be a discrepancy in the total mass\0A\00"
@.str.90 = [80 x i8] c" of all groups and the total mass of all particles in groups.\0A\00"
@.str.91 = [71 x i8] c" This discrepancy is reported at the end of the run.\0A\00"
@.str.92 = [86 x i8] c" - Group B particles that would have belonged to Group A are reported\0A\00"
@.str.93 = [72 x i8] c" as having been 'retained in the face of adversity.'\0A\0A\00"
define void @usage() {
%1 = load i32, i32* @stderr
%2 = call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.5, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.6, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.7, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.8, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.9, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.10, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.11, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.12, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.13, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.14, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.15, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.16, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.17, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.18, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.19, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.20, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.21, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.22, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.23, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.24, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.25, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.26, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.27, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.28, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.29, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.30, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.31, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.32, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.33, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = call i32 @fprintf(i32 %69, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.34, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = call i32 @fprintf(i32 %71, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.35, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.36, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.37, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = call i32 @fprintf(i32 %77, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.38, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = call i32 @fprintf(i32 %79, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.39, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.40, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.41, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.42, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = call i32 @fprintf(i32 %87, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.43, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.44, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.45, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = call i32 @fprintf(i32 %93, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.46, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = call i32 @fprintf(i32 %95, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.47, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.48, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = call i32 @fprintf(i32 %99, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.49, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.50, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = call i32 @fprintf(i32 %103, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.51, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.52, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = call i32 @fprintf(i32 %107, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.53, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = call i32 @fprintf(i32 %109, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.54, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = call i32 @fprintf(i32 %111, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.55, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = call i32 @fprintf(i32 %113, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.56, i64 0, i64 0))
%115 = load i32, i32* @stderr
%116 = call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.57, i64 0, i64 0))
%117 = load i32, i32* @stderr
%118 = call i32 @fprintf(i32 %117, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.58, i64 0, i64 0))
%119 = load i32, i32* @stderr
%120 = call i32 @fprintf(i32 %119, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.59, i64 0, i64 0))
%121 = load i32, i32* @stderr
%122 = call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.60, i64 0, i64 0))
%123 = load i32, i32* @stderr
%124 = call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.61, i64 0, i64 0))
%125 = load i32, i32* @stderr
%126 = call i32 @fprintf(i32 %125, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.62, i64 0, i64 0))
%127 = load i32, i32* @stderr
%128 = call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.63, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.64, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = call i32 @fprintf(i32 %131, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.65, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = call i32 @fprintf(i32 %133, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.66, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.67, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.68, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = call i32 @fprintf(i32 %139, i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.69, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.70, i64 0, i64 0))
%143 = load i32, i32* @stderr
%144 = call i32 @fprintf(i32 %143, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.71, i64 0, i64 0))
%145 = load i32, i32* @stderr
%146 = call i32 @fprintf(i32 %145, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.72, i64 0, i64 0))
%147 = load i32, i32* @stderr
%148 = call i32 @fprintf(i32 %147, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.73, i64 0, i64 0))
%149 = load i32, i32* @stderr
%150 = call i32 @fprintf(i32 %149, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.74, i64 0, i64 0))
%151 = load i32, i32* @stderr
%152 = call i32 @fprintf(i32 %151, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.75, i64 0, i64 0))
%153 = load i32, i32* @stderr
%154 = call i32 @fprintf(i32 %153, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.76, i64 0, i64 0))
%155 = load i32, i32* @stderr
%156 = call i32 @fprintf(i32 %155, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.77, i64 0, i64 0))
%157 = load i32, i32* @stderr
%158 = call i32 @fprintf(i32 %157, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.78, i64 0, i64 0))
%159 = load i32, i32* @stderr
%160 = call i32 @fprintf(i32 %159, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.79, i64 0, i64 0))
%161 = load i32, i32* @stderr
%162 = call i32 @fprintf(i32 %161, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.80, i64 0, i64 0))
%163 = load i32, i32* @stderr
%164 = call i32 @fprintf(i32 %163, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.81, i64 0, i64 0))
%165 = load i32, i32* @stderr
%166 = call i32 @fprintf(i32 %165, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.82, i64 0, i64 0))
%167 = load i32, i32* @stderr
%168 = call i32 @fprintf(i32 %167, i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.83, i64 0, i64 0))
%169 = load i32, i32* @stderr
%170 = call i32 @fprintf(i32 %169, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.84, i64 0, i64 0))
%171 = load i32, i32* @stderr
%172 = call i32 @fprintf(i32 %171, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.85, i64 0, i64 0))
%173 = load i32, i32* @stderr
%174 = call i32 @fprintf(i32 %173, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.86, i64 0, i64 0))
%175 = load i32, i32* @stderr
%176 = call i32 @fprintf(i32 %175, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.87, i64 0, i64 0))
%177 = load i32, i32* @stderr
%178 = call i32 @fprintf(i32 %177, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.88, i64 0, i64 0))
%179 = load i32, i32* @stderr
%180 = call i32 @fprintf(i32 %179, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.89, i64 0, i64 0))
%181 = load i32, i32* @stderr
%182 = call i32 @fprintf(i32 %181, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.90, i64 0, i64 0))
%183 = load i32, i32* @stderr
%184 = call i32 @fprintf(i32 %183, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.91, i64 0, i64 0))
%185 = load i32, i32* @stderr
%186 = call i32 @fprintf(i32 %185, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.92, i64 0, i64 0))
%187 = load i32, i32* @stderr
%188 = call i32 @fprintf(i32 %187, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.93, i64 0, i64 0))
%189 = call i32 @exit(i32 1)
unreachable
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [8 x i8] c"USAGE:\0A\00"
@.str.1 = [81 x i8] c"so -i <SKID .gtp file> [-o <outfilebase>] [([-dark] [-gas] [-star]) || [-all])]\0A\00"
@.str.2 = [72 x i8] c" [-mark <markfile>] [-std] [-grp] [-gtp] [-subsumed] [-ignored]\0A\00"
@.str.3 = [47 x i8] c" [-list <File containing group indexes>]\0A\00"
@.str.4 = [82 x i8] c" [-pot || -stat <SKID .stat file containing most-bound-particle positions>]\0A\00"
@.str.5 = [69 x i8] c" [-delta <fThreshold>] [-M <fMinGTPMass>] [-m <mMinSOMembers>]\0A\00"
@.str.6 = [46 x i8] c" [-O <fOmega0>] [-L] [-z <fRedshift>]\0A\00"
@.str.7 = [42 x i8] c" [-p <xyzPeriod>] [-c <xyzCenter>]\0A\00"
@.str.8 = [57 x i8] c" [-cx <xCenter>] [-cy <yCenter>] [-cz <zCenter>]\0A\00"
@.str.9 = [36 x i8] c" [-u <fMassUnit> <fMpcUnit>]\0A\0A\00"
@.str.10 = [75 x i8] c" Finds smallest spherical radius R within which the density is less than\0A\00"
@.str.11 = [78 x i8] c" the value <fThreshold> and calculates enclosed mass, half mass and quarter\0A\00"
@.str.12 = [74 x i8] c" mass radii, maximum circular velocity and max Vcirc radius, as well as\0A\00"
@.str.13 = [45 x i8] c" Vcirc in 1/4R increments from 1/4R to 2R.\0A\00"
@.str.14 = [67 x i8] c" -o: Main output will be written to file <outfilebase>.sovcirc.\0A\00"
@.str.15 = [30 x i8] c" default = so.sovcirc.\0A\00"
@.str.16 = [81 x i8] c" -dark -gas -star: Outputs radial profile of dark, gas, and/or star particles\0A\00"
@.str.17 = [67 x i8] c" in a separate file <outfilebase>.sodark / .sogas / .sostar\0A\00"
@.str.18 = [38 x i8] c" -all: same as '-dark -gas -star'.\0A\00"
@.str.19 = [77 x i8] c" -mark: Outputs radial profile of marked particles given in <markfile> to\0A\00"
@.str.20 = [49 x i8] c" to a separate file <outfilebase>.somark.\0A\00"
@.str.21 = [50 x i8] c" -std: Read and write standard TIPSY binaries.\0A\00"
@.str.22 = [74 x i8] c" -grp -gtp: Causes .sogrp and/or .sogtp file to be written. The group\0A\00"
@.str.23 = [78 x i8] c" numbers given in these output files are the SAME as the group numbers\0A\00"
@.str.24 = [81 x i8] c" in the input .gtp file. Groups in the .sogtp file that are not examined\0A\00"
@.str.25 = [77 x i8] c" at all will have 0 mass and 0 radius. Groups for which SO tries and\0A\00"
@.str.26 = [73 x i8] c" fails to find radius R will have mass 0 and '-errorcode' radius.\0A\00"
@.str.27 = [80 x i8] c" -pot: Center on the most bound particle of the group. Default is to center\0A\00"
@.str.28 = [78 x i8] c" on the group position as given in the input .gtp file. In this case,\0A\00"
@.str.29 = [79 x i8] c" the most bound particle is the particle within the radius of the input\0A\00"
@.str.30 = [72 x i8] c" groups that has the smallest Phi field given in the TIPSY file.\0A\00"
@.str.31 = [81 x i8] c" -stat: Center on the most bound particle as reported by the SKID .stat file.\0A\00"
@.str.32 = [80 x i8] c" This method is preferable to to -pot as SKID constructs potentials from\0A\00"
@.str.33 = [75 x i8] c" only those particles in the group and is not subject to the global\0A\00"
@.str.34 = [75 x i8] c" potential field. NOTE: this requires SKID revisions from 2/25/00.\0A\00"
@.str.35 = [83 x i8] c" -delta: By default, <fThreshold> is calculated automatically from cosmological\0A\00"
@.str.36 = [77 x i8] c" parameters to be the virial density, but may be overridden using the\0A\00"
@.str.37 = [70 x i8] c" -delta option by specifying the overdensity of the threshold.\0A\00"
@.str.38 = [44 x i8] c" -L: option will set Lambda0 = 1-Omega0.\0A\00"
@.str.39 = [78 x i8] c" -p: THIS VERSION ASSUMES PERIODIC BOUNDRY CONDITIONS. Default period = 1\0A\00"
@.str.40 = [80 x i8] c" -z: <fRedshift> will be automatically calculated as 1/h.time-1 where h.time\0A\00"
@.str.41 = [77 x i8] c" is read from the TIPSY particle file header. -z will override this.\0A\00"
@.str.42 = [81 x i8] c" -M: <fMinGTPMass> specifies the minimum mass a group given in the input .gtp\0A\00"
@.str.43 = [51 x i8] c" file must have in order to be considered.\0A\00"
@.str.44 = [79 x i8] c" -list: names an ASCII file which lists indexes of groups in the input .gtp\0A\00"
@.str.45 = [74 x i8] c" file to be considered. This may be used in conjunction with -M.\0A\00"
@.str.46 = [79 x i8] c" -m: <fMinSOMembers> specifies the minimum number of particles a group must\0A\00"
@.str.47 = [61 x i8] c" have for its parameters to be accurately calculated.\0A\00"
@.str.48 = [80 x i8] c" -u: Output is in system units unless simulation units are specified with -u\0A\00"
@.str.49 = [54 x i8] c" option, whereupon output will be in the form:\0A\00"
@.str.50 = [54 x i8] c" Mass [Msol], Distance [kpc], Velocity [km/s].\0A\00"
@.str.51 = [77 x i8] c" -subsumed/-ignored: causes .sosub/.soign TIPSY array files to be written\0A\00"
@.str.52 = [77 x i8] c" which give the number of times a particle was subsumed into a larger\0A\00"
@.str.53 = [81 x i8] c" group or ignored by a larger group because it belonged to a smaller one.\0A\00"
@.str.54 = [47 x i8] c"\0A See output file header for output format.\0A\0A\00"
@.str.55 = [75 x i8] c" Groupwise error codes are returned in Mvir and Rvir columns as follows:\0A\00"
@.str.56 = [80 x i8] c" -1.0: Fewer than nMembers particles within 1.2 times group's .grp radius\0A\00"
@.str.57 = [73 x i8] c" -2.0: Density < <fThreshold> within radius enclosing no more than\0A\00"
@.str.58 = [35 x i8] c" <nMembers> particles.\0A\00"
@.str.59 = [71 x i8] c" -3.0: Density > <fThreshold> beyond 3 times group's .grp radius\0A\00"
@.str.60 = [84 x i8] c" -Mvir: Group was 'subsumed' or 'slurped' by the group 'groupID' that is given\0A\00"
@.str.61 = [81 x i8] c" in the Rvir columns as -10*groupID. If the Vc columns are set with\0A\00"
@.str.62 = [80 x i8] c" meaningful numbers, then it was 'subsumed'. If the numbers are 0,\0A\00"
@.str.63 = [36 x i8] c" then it was 'slurped'.\0A\00"
@.str.64 = [53 x i8] c"\0A'Subsuming,' 'Slurping,' and 'Retaining' behavior:\0A\00"
@.str.65 = [86 x i8] c" The groups are SO'd in increasing order of SKID or FOF mass. This is an attempt\0A\00"
@.str.66 = [84 x i8] c" to produce the results whereby the most massive SO groups take precidence over\0A\00"
@.str.67 = [85 x i8] c" the smaller SO groups during a group collision. After SO finds the virial mass\0A\00"
@.str.68 = [90 x i8] c" and radius of group 'A', it examines the member particles of A to see if any of them\0A\00"
@.str.69 = [90 x i8] c" are members of other groups. When it encounters a particle that is already a member\0A\00"
@.str.70 = [48 x i8] c" of another group 'B' it checks as follows:\0A\00"
@.str.71 = [65 x i8] c" 1. If the center of B is within the virial radius of A:\0A\00"
@.str.72 = [62 x i8] c" - Zero all particles that were members of B.\0A\00"
@.str.73 = [79 x i8] c" - Mark Mvir and Rvir of B according to case 4 (-Mvir:) above.\0A\00"
@.str.74 = [82 x i8] c" - Tag all particles in the virial radius of A as belonging to A.\0A\00"
@.str.75 = [46 x i8] c" - Group B is now 'subsumed'.\0A\00"
@.str.76 = [70 x i8] c" 2. ELSE If the center of A is within the virial radius of B:\0A\00"
@.str.77 = [62 x i8] c" - Zero all particles that were members of A.\0A\00"
@.str.78 = [79 x i8] c" - Mark Mvir and Rvir of A according to case 4 (-Mvir:) above.\0A\00"
@.str.79 = [82 x i8] c" - Tag all particles in the virial radius of B as belonging to B.\0A\00"
@.str.80 = [87 x i8] c" - Group A is now 'slurped' by B. Thus, slurping is an odd case where\0A\00"
@.str.81 = [82 x i8] c" the Rvir of the smaller SKID or FOF group is *larger* than the\0A\00"
@.str.82 = [57 x i8] c" Rvir of the larger SKID or FOF group.\0A\00"
@.str.83 = [88 x i8] c" - Particles in Group A will be tabulated as 'subsumed' even though the\0A\00"
@.str.84 = [64 x i8] c" group itself will be tabulated as 'slurped.'\0A\00"
@.str.85 = [65 x i8] c" 2. ELSE Niether A nor B are within each other's radius:\0A\00"
@.str.86 = [57 x i8] c" - Group B retains all of its particles.\0A\00"
@.str.87 = [77 x i8] c" - However, all of the particles that fall within Rvir of A,\0A\00"
@.str.88 = [79 x i8] c" regardless of membership, are used in calculating group A's\0A\00"
@.str.89 = [84 x i8] c" quantities. Thus, there will be a discrepancy in the total mass\0A\00"
@.str.90 = [80 x i8] c" of all groups and the total mass of all particles in groups.\0A\00"
@.str.91 = [71 x i8] c" This discrepancy is reported at the end of the run.\0A\00"
@.str.92 = [86 x i8] c" - Group B particles that would have belonged to Group A are reported\0A\00"
@.str.93 = [72 x i8] c" as having been 'retained in the face of adversity.'\0A\0A\00"
define void @usage() {
%1 = load i32, i32* @stderr
%2 = tail call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = tail call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = tail call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = tail call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.5, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = tail call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.6, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.7, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = tail call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.8, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = tail call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.9, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = tail call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.10, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = tail call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.11, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = tail call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.12, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = tail call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.13, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = tail call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.14, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = tail call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.15, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = tail call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.16, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = tail call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.17, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = tail call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.18, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = tail call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.19, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = tail call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.20, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = tail call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.21, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = tail call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.22, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = tail call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.23, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = tail call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.24, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = tail call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.25, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = tail call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.26, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = tail call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.27, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = tail call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.28, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = tail call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.29, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = tail call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.30, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = tail call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.31, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = tail call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.32, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = tail call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.33, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = tail call i32 @fprintf(i32 %69, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.34, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = tail call i32 @fprintf(i32 %71, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.35, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = tail call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.36, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = tail call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.37, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = tail call i32 @fprintf(i32 %77, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.38, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = tail call i32 @fprintf(i32 %79, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.39, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = tail call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.40, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = tail call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.41, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = tail call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.42, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = tail call i32 @fprintf(i32 %87, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.43, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = tail call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.44, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = tail call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.45, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = tail call i32 @fprintf(i32 %93, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.46, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = tail call i32 @fprintf(i32 %95, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.47, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = tail call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.48, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = tail call i32 @fprintf(i32 %99, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.49, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = tail call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.50, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = tail call i32 @fprintf(i32 %103, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.51, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = tail call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.52, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = tail call i32 @fprintf(i32 %107, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.53, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = tail call i32 @fprintf(i32 %109, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.54, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = tail call i32 @fprintf(i32 %111, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.55, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = tail call i32 @fprintf(i32 %113, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.56, i64 0, i64 0))
%115 = load i32, i32* @stderr
%116 = tail call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.57, i64 0, i64 0))
%117 = load i32, i32* @stderr
%118 = tail call i32 @fprintf(i32 %117, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.58, i64 0, i64 0))
%119 = load i32, i32* @stderr
%120 = tail call i32 @fprintf(i32 %119, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.59, i64 0, i64 0))
%121 = load i32, i32* @stderr
%122 = tail call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.60, i64 0, i64 0))
%123 = load i32, i32* @stderr
%124 = tail call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.61, i64 0, i64 0))
%125 = load i32, i32* @stderr
%126 = tail call i32 @fprintf(i32 %125, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.62, i64 0, i64 0))
%127 = load i32, i32* @stderr
%128 = tail call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.63, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = tail call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.64, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = tail call i32 @fprintf(i32 %131, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.65, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = tail call i32 @fprintf(i32 %133, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.66, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = tail call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.67, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = tail call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.68, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = tail call i32 @fprintf(i32 %139, i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.69, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = tail call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.70, i64 0, i64 0))
%143 = load i32, i32* @stderr
%144 = tail call i32 @fprintf(i32 %143, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.71, i64 0, i64 0))
%145 = load i32, i32* @stderr
%146 = tail call i32 @fprintf(i32 %145, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.72, i64 0, i64 0))
%147 = load i32, i32* @stderr
%148 = tail call i32 @fprintf(i32 %147, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.73, i64 0, i64 0))
%149 = load i32, i32* @stderr
%150 = tail call i32 @fprintf(i32 %149, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.74, i64 0, i64 0))
%151 = load i32, i32* @stderr
%152 = tail call i32 @fprintf(i32 %151, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.75, i64 0, i64 0))
%153 = load i32, i32* @stderr
%154 = tail call i32 @fprintf(i32 %153, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.76, i64 0, i64 0))
%155 = load i32, i32* @stderr
%156 = tail call i32 @fprintf(i32 %155, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.77, i64 0, i64 0))
%157 = load i32, i32* @stderr
%158 = tail call i32 @fprintf(i32 %157, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.78, i64 0, i64 0))
%159 = load i32, i32* @stderr
%160 = tail call i32 @fprintf(i32 %159, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.79, i64 0, i64 0))
%161 = load i32, i32* @stderr
%162 = tail call i32 @fprintf(i32 %161, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.80, i64 0, i64 0))
%163 = load i32, i32* @stderr
%164 = tail call i32 @fprintf(i32 %163, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.81, i64 0, i64 0))
%165 = load i32, i32* @stderr
%166 = tail call i32 @fprintf(i32 %165, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.82, i64 0, i64 0))
%167 = load i32, i32* @stderr
%168 = tail call i32 @fprintf(i32 %167, i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.83, i64 0, i64 0))
%169 = load i32, i32* @stderr
%170 = tail call i32 @fprintf(i32 %169, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.84, i64 0, i64 0))
%171 = load i32, i32* @stderr
%172 = tail call i32 @fprintf(i32 %171, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.85, i64 0, i64 0))
%173 = load i32, i32* @stderr
%174 = tail call i32 @fprintf(i32 %173, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.86, i64 0, i64 0))
%175 = load i32, i32* @stderr
%176 = tail call i32 @fprintf(i32 %175, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.87, i64 0, i64 0))
%177 = load i32, i32* @stderr
%178 = tail call i32 @fprintf(i32 %177, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.88, i64 0, i64 0))
%179 = load i32, i32* @stderr
%180 = tail call i32 @fprintf(i32 %179, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.89, i64 0, i64 0))
%181 = load i32, i32* @stderr
%182 = tail call i32 @fprintf(i32 %181, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.90, i64 0, i64 0))
%183 = load i32, i32* @stderr
%184 = tail call i32 @fprintf(i32 %183, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.91, i64 0, i64 0))
%185 = load i32, i32* @stderr
%186 = tail call i32 @fprintf(i32 %185, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.92, i64 0, i64 0))
%187 = load i32, i32* @stderr
%188 = tail call i32 @fprintf(i32 %187, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.93, i64 0, i64 0))
%189 = tail call i32 @exit(i32 1)
unreachable
}