OpenCOBOL 1.1pre-rel
Defines | Functions
OCic.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <libcob.h>
#include "OCic.c.h"
#include "OCic.c.l1.h"
#include "OCic.c.l2.h"
#include "OCic.c.l3.h"
#include "OCic.c.l4.h"
Include dependency graph for OCic.c:

Go to the source code of this file.

Defines

#define __USE_STRING_INLINES   1
#define COB_SOURCE_FILE   "OCic.cbl"
#define COB_PACKAGE_VERSION   "1.1"
#define COB_PATCH_LEVEL   0

Functions

static void cob_decimal_set_int (cob_decimal *d, const int n)
int OCic ()
static int OCic1 (const int)
int GETOSTYPE (void)
static int GETOSTYPE_ (const int)
int CHECKSOURCE (unsigned char *, unsigned char *)
static int CHECKSOURCE_ (const int, unsigned char *, unsigned char *)
int LISTING (unsigned char *, unsigned char *, unsigned char *)
static int LISTING_ (const int, unsigned char *, unsigned char *, unsigned char *)
int main (int argc, char **argv)

Define Documentation

#define __USE_STRING_INLINES   1

Definition at line 8 of file OCic.c.

#define COB_PACKAGE_VERSION   "1.1"

Definition at line 16 of file OCic.c.

#define COB_PATCH_LEVEL   0

Definition at line 17 of file OCic.c.

#define COB_SOURCE_FILE   "OCic.cbl"

Definition at line 15 of file OCic.c.


Function Documentation

int CHECKSOURCE ( unsigned char *  b_372,
unsigned char *  b_374 
)

Definition at line 3721 of file OCic.c.

{
  return CHECKSOURCE_ (0, b_372, b_374);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int CHECKSOURCE_ ( const int  entry,
unsigned char *  b_372,
unsigned char *  b_374 
) [static]

Definition at line 3727 of file OCic.c.

{
  /* Local variables */
  #include "OCic.c.l3.h"

  static int initialized = 0;
  static cob_field *cob_user_parameters[COB_MAX_FIELD_PARAMS];
  static struct cob_module module = { NULL, NULL, NULL, NULL, cob_user_parameters, 0, '.', '$', ',', 1, 1, 1, 0 };

  /* Start of function code */

  /* CANCEL callback handling */
  if (unlikely(entry < 0)) {
        if (!initialized) {
                return 0;
        }
        initialized = 0;
        return 0;
  }

  /* Initialize frame stack */
  frame_ptr = &frame_stack[0];
  frame_ptr->perform_through = 0;

  /* Push module stack */
  module.next = cob_current_module;
  cob_current_module = &module;

  /* Initialize program */
  if (unlikely(initialized == 0))
    {
      if (!cob_initialized) {
        cob_fatal_error (COB_FERROR_INITIALIZED);
      }
      cob_check_version (COB_SOURCE_FILE, COB_PACKAGE_VERSION, COB_PATCH_LEVEL);
      if (module.next)
        cob_set_cancel ((const char *)"CHECKSOURCE", (void *)CHECKSOURCE, (void *)CHECKSOURCE_);
      (*(int *) (b_360)) = 0;
      memset (b_364, 32, 80);
      *(unsigned char *)(b_366) = 32;
      *(unsigned char *)(b_370) = 0;
      *(unsigned char *)(b_371) = 0;
      initialized = 1;
    }

  cob_save_call_params = cob_call_params;

  /* Entry dispatch */
  goto l_64;

  /* PROCEDURE DIVISION */

  /* Entry CHECKSOURCE */

  l_64:;

  /* 000-Main SECTION */

  /* 010-Initialize */

  /* OCic.cbl:1698: SET */
  {
    *(b_374) = 32;
  }
  /* OCic.cbl:1699: IF */
  {
    if (((int)(int)(*(b_372 + 6) - 42) == 0))
      {
        /* OCic.cbl:1700: GOBACK */
        {
          goto exit_program;
        }
      }
  }

  /* 020-Compress-Multiple-SPACES */

  /* OCic.cbl:1705: SET */
  {
    *(b_366) = 78;
  }
  /* OCic.cbl:1706: MOVE */
  {
    (*(signed char *) (b_371)) = 0;
  }
  /* OCic.cbl:1707: MOVE */
  {
    memset (b_364, 32, 80);
  }
  /* OCic.cbl:1708: PERFORM */
  {
    (*(signed char *) (b_370)) = 1;
    while (1)
      {
        if (((int)cob_cmp_s8_binary (b_370, 80) >  0))
          break;
        {
          /* OCic.cbl:1710: IF */
          {
            if (((int)(int)(*(b_372 + ((*(signed char *) (b_370)) - 1)) - ' ') == 0))
              {
                /* OCic.cbl:1711: IF */
                {
                  if (((int)(int)(*(b_366) - 78) == 0))
                    {
                      /* OCic.cbl:1712: ADD */
                      {
                        (*(signed char *) (b_371)) = ((*(signed char *) (b_371)) + 1);
                      }
                      /* OCic.cbl:1713: MOVE */
                      {
                        cob_move (cob_intr_upper_case (0, 0, (f0.size = 1, f0.data = b_372 + ((*(signed char *) (b_370)) - 1), f0.attr = &a_2, &f0)), (f1.size = 1, f1.data = b_364 + ((*(signed char *) (b_371)) - 1), f1.attr = &a_2, &f1));
                      }
                      /* OCic.cbl:1714: SET */
                      {
                        *(b_366) = 89;
                      }
                    }
                }
              }
            else
              {
                /* OCic.cbl:1717: SET */
                {
                  *(b_366) = 78;
                }
                /* OCic.cbl:1718: ADD */
                {
                  (*(signed char *) (b_371)) = ((*(signed char *) (b_371)) + 1);
                }
                /* OCic.cbl:1719: MOVE */
                {
                  *(b_364 + ((*(signed char *) (b_371)) - 1)) = *(b_372 + ((*(signed char *) (b_370)) - 1));
                }
              }
          }
        }
        (*(signed char *) (b_370)) = ((*(signed char *) (b_370)) + 1);
      }
  }

  /* 030-Scan-Compressed-Src */

  /* OCic.cbl:1725: PERFORM */
  {
    (*(signed char *) (b_370)) = 1;
    while (1)
      {
        if (((int)cob_cmp_s8_binary (b_370, 66) >  0))
          break;
        {
          /* OCic.cbl:1727: EVALUATE */
          {
            if (((int)(int)(*(b_364 + ((*(signed char *) (b_370)) - 1)) - 42) == 0))
              {
                /* OCic.cbl:1729: IF */
                {
                  if (((int)memcmp (b_364 + ((*(signed char *) (b_370)) - 1), (unsigned char *)"*>", 2) == 0))
                    {
                      /* OCic.cbl:1730: GOBACK */
                      {
                        goto exit_program;
                      }
                    }
                }
              }
            else
              if ((((int)(int)(*(b_364 + ((*(signed char *) (b_370)) - 1)) - 76) == 0) && ((int)cob_cmp_s8_binary (b_370, 66) <  0)))
                {
                  /* OCic.cbl:1733: IF */
                  {
                    if (((int)memcmp (b_364 + ((*(signed char *) (b_370)) - 1), (unsigned char *)"LINKAGE SECTION", 15) == 0))
                      {
                        /* OCic.cbl:1734: SET */
                        {
                          *(b_374) = 76;
                        }
                        /* OCic.cbl:1735: GOBACK */
                        {
                          goto exit_program;
                        }
                      }
                  }
                }
              else
                if ((((int)(int)(*(b_364 + ((*(signed char *) (b_370)) - 1)) - 73) == 0) && ((int)cob_cmp_s8_binary (b_370, 58) <  0)))
                  {
                    /* OCic.cbl:1738: IF */
                    {
                      if (((int)memcmp (b_364 + ((*(signed char *) (b_370)) - 1), (unsigned char *)"IDENTIFICATION DIVISION", 23) == 0))
                        {
                          /* OCic.cbl:1740: SET */
                          {
                            *(b_374) = 73;
                          }
                          /* OCic.cbl:1741: GOBACK */
                          {
                            goto exit_program;
                          }
                        }
                    }
                  }
          }
        }
        (*(signed char *) (b_370)) = ((*(signed char *) (b_370)) + 1);
      }
  }

  /* 099-Never-Found-Either-One */

  /* OCic.cbl:1748: GOBACK */
  {
    goto exit_program;
  }

  /* Program exit */

  exit_program:

  /* Pop module stack */
  cob_current_module = cob_current_module->next;

  /* Program return */
  return (*(int *) (b_360));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cob_decimal_set_int ( cob_decimal d,
const int  n 
) [static]

Definition at line 23 of file OCic.c.

{
        mpz_set_si (d->value, n);
        d->scale = 0;
}

Here is the caller graph for this function:

int GETOSTYPE ( void  )

Definition at line 3553 of file OCic.c.

{
  return GETOSTYPE_ (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int GETOSTYPE_ ( const int  entry) [static]

Definition at line 3559 of file OCic.c.

{
  /* Local variables */
  #include "OCic.c.l2.h"

  static int initialized = 0;
  static cob_field *cob_user_parameters[COB_MAX_FIELD_PARAMS];
  static struct cob_module module = { NULL, NULL, NULL, NULL, cob_user_parameters, 0, '.', '$', ',', 1, 1, 1, 0 };

  /* Start of function code */

  /* CANCEL callback handling */
  if (unlikely(entry < 0)) {
        if (!initialized) {
                return 0;
        }
        initialized = 0;
        return 0;
  }

  /* Initialize frame stack */
  frame_ptr = &frame_stack[0];
  frame_ptr->perform_through = 0;

  /* Push module stack */
  module.next = cob_current_module;
  cob_current_module = &module;

  /* Initialize program */
  if (unlikely(initialized == 0))
    {
      if (!cob_initialized) {
        cob_fatal_error (COB_FERROR_INITIALIZED);
      }
      cob_check_version (COB_SOURCE_FILE, COB_PACKAGE_VERSION, COB_PATCH_LEVEL);
      if (module.next)
        cob_set_cancel ((const char *)"GETOSTYPE", (void *)GETOSTYPE, (void *)GETOSTYPE_);
      (*(int *) (b_353)) = 0;
      memset (b_357, 32, 1024);
      memset (b_358, 0, 4);
      initialized = 1;
    }

  cob_save_call_params = cob_call_params;

  /* Entry dispatch */
  goto l_61;

  /* PROCEDURE DIVISION */

  /* Entry GETOSTYPE */

  l_61:;

  /* 000-Main SECTION */

  /* 010-Get-TEMP-Var */

  /* OCic.cbl:1623: MOVE */
  {
    memset (b_357, 32, 1024);
  }
  /* OCic.cbl:1624: ACCEPT */
  cob_exception_code = 0;
  {
    cob_get_environment (&c_172, &f_357);
  }
  if (unlikely(cob_exception_code == 0x0601))
    {
      {
        /* OCic.cbl:1627: MOVE */
        {
          (*(int *) (b_353)) = 0;
        }
        /* OCic.cbl:1628: GOBACK */
        {
          goto exit_program;
        }
      }
    }
  /* OCic.cbl:1630: IF */
  {
    if (((int)cob_cmp (&f_357, &cob_space) == 0))
      {
        /* OCic.cbl:1631: MOVE */
        {
          (*(int *) (b_353)) = 0;
        }
      }
    else
      {
        /* OCic.cbl:1633: MOVE */
        {
          (*(int *)(b_358)) = 0;
        }
        /* OCic.cbl:1634: INSPECT */
        {
          cob_inspect_init (&f_357, 0);
          cob_inspect_start ();
          cob_inspect_all (&f_358, &c_173);
          cob_inspect_finish ();
        }
        /* OCic.cbl:1636: IF */
        {
          if (((int)cob_cmp_s32_binary (b_358, 0) == 0))
            {
              /* OCic.cbl:1637: MOVE */
              {
                (*(int *)(b_358)) = 0;
              }
              /* OCic.cbl:1638: INSPECT */
              {
                cob_inspect_init (&f_357, 0);
                cob_inspect_start ();
                cob_inspect_all (&f_358, &c_167);
                cob_inspect_finish ();
              }
              /* OCic.cbl:1640: IF */
              {
                if (((int)cob_cmp_s32_binary (b_358, 0) == 0))
                  {
                    /* OCic.cbl:1641: MOVE */
                    {
                      (*(int *) (b_353)) = 3;
                    }
                  }
                else
                  {
                    /* OCic.cbl:1643: MOVE */
                    {
                      (*(int *) (b_353)) = 2;
                    }
                  }
              }
            }
          else
            {
              /* OCic.cbl:1646: MOVE */
              {
                (*(int *) (b_353)) = 1;
              }
            }
        }
      }
  }
  /* OCic.cbl:1649: GOBACK */
  {
    goto exit_program;
  }

  /* Program exit */

  exit_program:

  /* Pop module stack */
  cob_current_module = cob_current_module->next;

  /* Program return */
  return (*(int *) (b_353));
}

Here is the call graph for this function:

Here is the caller graph for this function:

int LISTING ( unsigned char *  b_1107,
unsigned char *  b_1108,
unsigned char *  b_1109 
)

Definition at line 3954 of file OCic.c.

{
  return LISTING_ (0, b_1107, b_1108, b_1109);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int LISTING_ ( const int  entry,
unsigned char *  b_1107,
unsigned char *  b_1108,
unsigned char *  b_1109 
) [static]

Definition at line 3960 of file OCic.c.

{
  /* Local variables */
  #include "OCic.c.l4.h"

  static int initialized = 0;
  static cob_field *cob_user_parameters[COB_MAX_FIELD_PARAMS];
  static struct cob_module module = { NULL, NULL, NULL, NULL, cob_user_parameters, 0, '.', '$', ',', 1, 1, 1, 0 };

  /* Start of function code */

  /* CANCEL callback handling */
  if (unlikely(entry < 0)) {
        if (!initialized) {
                return 0;
        }
        cob_close (h_EXPAND_CODE, 0, NULL);
        cob_close (h_REPORT_FILE, 0, NULL);
        cob_close (h_SOURCE_CODE, 0, NULL);
        mpz_clear (d0.value);
        d0.scale = 0;
        mpz_clear (d1.value);
        d1.scale = 0;
        initialized = 0;
        return 0;
  }

  /* Initialize frame stack */
  frame_ptr = &frame_stack[0];
  frame_ptr->perform_through = 0;

  /* Push module stack */
  module.next = cob_current_module;
  cob_current_module = &module;

  /* Initialize program */
  if (unlikely(initialized == 0))
    {
      if (!cob_initialized) {
        cob_fatal_error (COB_FERROR_INITIALIZED);
      }
      cob_check_version (COB_SOURCE_FILE, COB_PACKAGE_VERSION, COB_PATCH_LEVEL);
      if (module.next)
        cob_set_cancel ((const char *)"LISTING", (void *)LISTING, (void *)LISTING_);
      /* Initialize decimal numbers */
      cob_decimal_init (&d0);
      cob_decimal_init (&d1);

      (*(int *) (b_379)) = 0;
      (*(int *) (b_380)) = 0;
      (*(int *) (b_1063)) = 1;
      memset (b_410, 32, 256);
      memset (b_411, 32, 2);
      cob_move (&cob_zero, &f_413);
      memset (b_412 + 6, 32, 129);
      memset (b_416, 32, 49);
      cob_move (&cob_zero, &f_421);
      memset (b_416 + 55, 32, 17);
      for (i1 = 1; i1 <= 8; i1++)
        {
          cob_move (&cob_zero, (f0.size = 6, f0.data = b_416 + 72 + 8 * (i1 - 1), f0.attr = &a_8, &f0));
          memset (b_416 + 78 + 8 * (i1 - 1), 32, 2);
        }
      *(unsigned char *)(b_429) = 32;
      memset (b_430, 32, 256);
      memset (b_431, 32, 256);
      memset (b_432, 32, 256);
      memset (b_433, 32, 7);
      memset (b_443, 32, 47);
      memcpy (b_446, "OpenCOBOL 1.1 06FEB2009 Source Listing - OCic Copyright (C) 2009-2010, Gary L. Cutler, GPL", 90);
      memset (b_446 + 90, 32, 35);
      cob_move (&cob_zero, &f_448);
      memcpy (b_449, "OpenCOBOL 1.1 06FEB2009 Cross-Reference Listing - OCic Copyright (C) 2009-2010, Gary L. Cutler, GPL", 99);
      memset (b_449 + 99, 32, 26);
      cob_move (&cob_zero, &f_451);
      memset (b_452, 32, 135);
      memcpy (b_453, "Line   Statement", 16);
      memcpy (b_454, "PROGRAM-ID      Identifier/Register/Function     Defn   Where Defined   References (* = Updated)", 96);
      memcpy (b_455, "====== ", 7);
      memset (b_455 + 7, 61, 128);
      memcpy (b_456, "=============== ================================ ====== =============== ", 72);
      memset (b_456 + 72, 61, 63);
      memset (b_457, 32, 100);
      memset (b_458, 0, 4);
      memset (b_459, 0, 4);
      memset (b_460, 0, 4);
      memset (b_461, 0, 4);
      memset (b_462, 32, 256);
      memset (b_463, 0, 4);
      memset (b_464, 32, 10);
      memset (b_465, 32, 32);
      memset (b_466, 32, 256);
      memset (b_467, 32, 256);
      memset (b_468, 32, 256);
      memcpy (b_469, "IABS", 4);
      memset (b_469 + 4, 32, 29);
      memcpy (b_469 + 33, "VACCEPT", 7);
      memset (b_469 + 33 + 7, 32, 26);
      memcpy (b_469 + 66, " ACCESS", 7);
      memset (b_469 + 66 + 7, 32, 26);
      memcpy (b_469 + 99, "IACOS", 5);
      memset (b_469 + 99 + 5, 32, 28);
      memcpy (b_469 + 132, " ACTIVE-CLASS", 13);
      memset (b_469 + 132 + 13, 32, 20);
      memcpy (b_469 + 165, "VADD", 4);
      memset (b_469 + 165 + 4, 32, 29);
      memcpy (b_469 + 198, " ADDRESS", 8);
      memset (b_469 + 198 + 8, 32, 25);
      memcpy (b_469 + 231, " ADVANCING", 10);
      memset (b_469 + 231 + 10, 32, 23);
      memcpy (b_469 + 264, "KAFTER", 6);
      memset (b_469 + 264 + 6, 32, 27);
      memcpy (b_469 + 297, " ALIGNED", 8);
      memset (b_469 + 297 + 8, 32, 25);
      memcpy (b_469 + 330, " ALL", 4);
      memset (b_469 + 330 + 4, 32, 29);
      memcpy (b_469 + 363, "VALLOCATE", 9);
      memset (b_469 + 363 + 9, 32, 24);
      memcpy (b_469 + 396, " ALPHABET", 9);
      memset (b_469 + 396 + 9, 32, 24);
      memcpy (b_469 + 429, " ALPHABETIC", 11);
      memset (b_469 + 429 + 11, 32, 22);
      memcpy (b_469 + 462, " ALPHABETIC-LOWER", 17);
      memset (b_469 + 462 + 17, 32, 16);
      memcpy (b_469 + 495, " ALPHABETIC-UPPER", 17);
      memset (b_469 + 495 + 17, 32, 16);
      memcpy (b_469 + 528, " ALPHANUMERIC", 13);
      memset (b_469 + 528 + 13, 32, 20);
      memcpy (b_469 + 561, " ALPHANUMERIC-EDITED", 20);
      memset (b_469 + 561 + 20, 32, 13);
      memcpy (b_469 + 594, " ALSO", 5);
      memset (b_469 + 594 + 5, 32, 28);
      memcpy (b_469 + 627, "VALTER", 6);
      memset (b_469 + 627 + 6, 32, 27);
      memcpy (b_469 + 660, " ALTERNATE", 10);
      memset (b_469 + 660 + 10, 32, 23);
      memcpy (b_469 + 693, " AND", 4);
      memset (b_469 + 693 + 4, 32, 29);
      memcpy (b_469 + 726, "IANNUITY", 8);
      memset (b_469 + 726 + 8, 32, 25);
      memcpy (b_469 + 759, " ANY", 4);
      memset (b_469 + 759 + 4, 32, 29);
      memcpy (b_469 + 792, " ANYCASE", 8);
      memset (b_469 + 792 + 8, 32, 25);
      memcpy (b_469 + 825, " ARE", 4);
      memset (b_469 + 825 + 4, 32, 29);
      memcpy (b_469 + 858, " AREA", 5);
      memset (b_469 + 858 + 5, 32, 28);
      memcpy (b_469 + 891, " AREAS", 6);
      memset (b_469 + 891 + 6, 32, 27);
      memcpy (b_469 + 924, " ARGUMENT-NUMBER", 16);
      memset (b_469 + 924 + 16, 32, 17);
      memcpy (b_469 + 957, " ARGUMENT-VALUE", 15);
      memset (b_469 + 957 + 15, 32, 18);
      memcpy (b_469 + 990, " AS", 3);
      memset (b_469 + 990 + 3, 32, 30);
      memcpy (b_469 + 1023, " ASCENDING", 10);
      memset (b_469 + 1023 + 10, 32, 23);
      memcpy (b_469 + 1056, "IASIN", 5);
      memset (b_469 + 1056 + 5, 32, 28);
      memcpy (b_469 + 1089, " ASSIGN", 7);
      memset (b_469 + 1089 + 7, 32, 26);
      memcpy (b_469 + 1122, " AT", 3);
      memset (b_469 + 1122 + 3, 32, 30);
      memcpy (b_469 + 1155, "IATAN", 5);
      memset (b_469 + 1155 + 5, 32, 28);
      memcpy (b_469 + 1188, " AUTHOR", 7);
      memset (b_469 + 1188 + 7, 32, 26);
      memcpy (b_469 + 1221, " AUTO", 5);
      memset (b_469 + 1221 + 5, 32, 28);
      memcpy (b_469 + 1254, " AUTO-SKIP", 10);
      memset (b_469 + 1254 + 10, 32, 23);
      memcpy (b_469 + 1287, " AUTOMATIC", 10);
      memset (b_469 + 1287 + 10, 32, 23);
      memcpy (b_469 + 1320, " AUTOTERMINATE", 14);
      memset (b_469 + 1320 + 14, 32, 19);
      memcpy (b_469 + 1353, " BACKGROUND-COLOR", 17);
      memset (b_469 + 1353 + 17, 32, 16);
      memcpy (b_469 + 1386, " BASED", 6);
      memset (b_469 + 1386 + 6, 32, 27);
      memcpy (b_469 + 1419, " BEEP", 5);
      memset (b_469 + 1419 + 5, 32, 28);
      memcpy (b_469 + 1452, " BEFORE", 7);
      memset (b_469 + 1452 + 7, 32, 26);
      memcpy (b_469 + 1485, " BELL", 5);
      memset (b_469 + 1485 + 5, 32, 28);
      memcpy (b_469 + 1518, " BINARY", 7);
      memset (b_469 + 1518 + 7, 32, 26);
      memcpy (b_469 + 1551, " BINARY-C-LONG", 14);
      memset (b_469 + 1551 + 14, 32, 19);
      memcpy (b_469 + 1584, " BINARY-CHAR", 12);
      memset (b_469 + 1584 + 12, 32, 21);
      memcpy (b_469 + 1617, " BINARY-DOUBLE", 14);
      memset (b_469 + 1617 + 14, 32, 19);
      memcpy (b_469 + 1650, " BINARY-LONG", 12);
      memset (b_469 + 1650 + 12, 32, 21);
      memcpy (b_469 + 1683, " BINARY-SHORT", 13);
      memset (b_469 + 1683 + 13, 32, 20);
      memcpy (b_469 + 1716, " BIT", 4);
      memset (b_469 + 1716 + 4, 32, 29);
      memcpy (b_469 + 1749, " BLANK", 6);
      memset (b_469 + 1749 + 6, 32, 27);
      memcpy (b_469 + 1782, " BLINK", 6);
      memset (b_469 + 1782 + 6, 32, 27);
      memcpy (b_469 + 1815, " BLOCK", 6);
      memset (b_469 + 1815 + 6, 32, 27);
      memcpy (b_469 + 1848, " BOOLEAN", 8);
      memset (b_469 + 1848 + 8, 32, 25);
      memcpy (b_469 + 1881, " BOTTOM", 7);
      memset (b_469 + 1881 + 7, 32, 26);
      memcpy (b_469 + 1914, "YBY", 3);
      memset (b_469 + 1914 + 3, 32, 30);
      memcpy (b_469 + 1947, "IBYTE-LENGTH", 12);
      memset (b_469 + 1947 + 12, 32, 21);
      memcpy (b_469 + 1980, "MC01", 4);
      memset (b_469 + 1980 + 4, 32, 29);
      memcpy (b_469 + 2013, "MC02", 4);
      memset (b_469 + 2013 + 4, 32, 29);
      memcpy (b_469 + 2046, "MC03", 4);
      memset (b_469 + 2046 + 4, 32, 29);
      memcpy (b_469 + 2079, "MC04", 4);
      memset (b_469 + 2079 + 4, 32, 29);
      memcpy (b_469 + 2112, "MC05", 4);
      memset (b_469 + 2112 + 4, 32, 29);
      memcpy (b_469 + 2145, "MC06", 4);
      memset (b_469 + 2145 + 4, 32, 29);
      memcpy (b_469 + 2178, "MC07", 4);
      memset (b_469 + 2178 + 4, 32, 29);
      memcpy (b_469 + 2211, "MC08", 4);
      memset (b_469 + 2211 + 4, 32, 29);
      memcpy (b_469 + 2244, "MC09", 4);
      memset (b_469 + 2244 + 4, 32, 29);
      memcpy (b_469 + 2277, "MC10", 4);
      memset (b_469 + 2277 + 4, 32, 29);
      memcpy (b_469 + 2310, "MC11", 4);
      memset (b_469 + 2310 + 4, 32, 29);
      memcpy (b_469 + 2343, "MC12", 4);
      memset (b_469 + 2343 + 4, 32, 29);
      memcpy (b_469 + 2376, "VCALL", 5);
      memset (b_469 + 2376 + 5, 32, 28);
      memcpy (b_469 + 2409, "VCANCEL", 7);
      memset (b_469 + 2409 + 7, 32, 26);
      memcpy (b_469 + 2442, " CF", 3);
      memset (b_469 + 2442 + 3, 32, 30);
      memcpy (b_469 + 2475, " CH", 3);
      memset (b_469 + 2475 + 3, 32, 30);
      memcpy (b_469 + 2508, " CHAINING", 9);
      memset (b_469 + 2508 + 9, 32, 24);
      memcpy (b_469 + 2541, "ICHAR", 5);
      memset (b_469 + 2541 + 5, 32, 28);
      memcpy (b_469 + 2574, " CHARACTER", 10);
      memset (b_469 + 2574 + 10, 32, 23);
      memcpy (b_469 + 2607, " CHARACTERS", 11);
      memset (b_469 + 2607 + 11, 32, 22);
      memcpy (b_469 + 2640, " CLASS", 6);
      memset (b_469 + 2640 + 6, 32, 27);
      memcpy (b_469 + 2673, " CLASS-ID", 9);
      memset (b_469 + 2673 + 9, 32, 24);
      memcpy (b_469 + 2706, "VCLOSE", 6);
      memset (b_469 + 2706 + 6, 32, 27);
      memcpy (b_469 + 2739, "ICOB-CRT-STATUS", 15);
      memset (b_469 + 2739 + 15, 32, 18);
      memcpy (b_469 + 2772, " CODE", 5);
      memset (b_469 + 2772 + 5, 32, 28);
      memcpy (b_469 + 2805, " CODE-SET", 9);
      memset (b_469 + 2805 + 9, 32, 24);
      memcpy (b_469 + 2838, " COL", 4);
      memset (b_469 + 2838 + 4, 32, 29);
      memcpy (b_469 + 2871, " COLLATING", 10);
      memset (b_469 + 2871 + 10, 32, 23);
      memcpy (b_469 + 2904, " COLS", 5);
      memset (b_469 + 2904 + 5, 32, 28);
      memcpy (b_469 + 2937, " COLUMN", 7);
      memset (b_469 + 2937 + 7, 32, 26);
      memcpy (b_469 + 2970, " COLUMNS", 8);
      memset (b_469 + 2970 + 8, 32, 25);
      memcpy (b_469 + 3003, "ICOMBINED-DATETIME", 18);
      memset (b_469 + 3003 + 18, 32, 15);
      memcpy (b_469 + 3036, " COMMA", 6);
      memset (b_469 + 3036 + 6, 32, 27);
      memcpy (b_469 + 3069, " COMMAND-LINE", 13);
      memset (b_469 + 3069 + 13, 32, 20);
      memcpy (b_469 + 3102, "VCOMMIT", 7);
      memset (b_469 + 3102 + 7, 32, 26);
      memcpy (b_469 + 3135, " COMMON", 7);
      memset (b_469 + 3135 + 7, 32, 26);
      memcpy (b_469 + 3168, " COMP", 5);
      memset (b_469 + 3168 + 5, 32, 28);
      memcpy (b_469 + 3201, " COMP-1", 7);
      memset (b_469 + 3201 + 7, 32, 26);
      memcpy (b_469 + 3234, " COMP-2", 7);
      memset (b_469 + 3234 + 7, 32, 26);
      memcpy (b_469 + 3267, " COMP-3", 7);
      memset (b_469 + 3267 + 7, 32, 26);
      memcpy (b_469 + 3300, " COMP-4", 7);
      memset (b_469 + 3300 + 7, 32, 26);
      memcpy (b_469 + 3333, " COMP-5", 7);
      memset (b_469 + 3333 + 7, 32, 26);
      memcpy (b_469 + 3366, " COMP-X", 7);
      memset (b_469 + 3366 + 7, 32, 26);
      memcpy (b_469 + 3399, " COMPUTATIONAL", 14);
      memset (b_469 + 3399 + 14, 32, 19);
      memcpy (b_469 + 3432, " COMPUTATIONAL-1", 16);
      memset (b_469 + 3432 + 16, 32, 17);
      memcpy (b_469 + 3465, " COMPUTATIONAL-2", 16);
      memset (b_469 + 3465 + 16, 32, 17);
      memcpy (b_469 + 3498, " COMPUTATIONAL-3", 16);
      memset (b_469 + 3498 + 16, 32, 17);
      memcpy (b_469 + 3531, " COMPUTATIONAL-4", 16);
      memset (b_469 + 3531 + 16, 32, 17);
      memcpy (b_469 + 3564, " COMPUTATIONAL-5", 16);
      memset (b_469 + 3564 + 16, 32, 17);
      memcpy (b_469 + 3597, " COMPUTATIONAL-X", 16);
      memset (b_469 + 3597 + 16, 32, 17);
      memcpy (b_469 + 3630, "VCOMPUTE", 8);
      memset (b_469 + 3630 + 8, 32, 25);
      memcpy (b_469 + 3663, "ICONCATENATE", 12);
      memset (b_469 + 3663 + 12, 32, 21);
      memcpy (b_469 + 3696, " CONDITION", 10);
      memset (b_469 + 3696 + 10, 32, 23);
      memcpy (b_469 + 3729, "KCONFIGURATION", 14);
      memset (b_469 + 3729 + 14, 32, 19);
      memcpy (b_469 + 3762, "MCONSOLE", 8);
      memset (b_469 + 3762 + 8, 32, 25);
      memcpy (b_469 + 3795, " CONSTANT", 9);
      memset (b_469 + 3795 + 9, 32, 24);
      memcpy (b_469 + 3828, " CONTAINS", 9);
      memset (b_469 + 3828 + 9, 32, 24);
      memcpy (b_469 + 3861, " CONTENT", 8);
      memset (b_469 + 3861 + 8, 32, 25);
      memcpy (b_469 + 3894, "VCONTINUE", 9);
      memset (b_469 + 3894 + 9, 32, 24);
      memcpy (b_469 + 3927, " CONTROL", 8);
      memset (b_469 + 3927 + 8, 32, 25);
      memcpy (b_469 + 3960, " CONTROLS", 9);
      memset (b_469 + 3960 + 9, 32, 24);
      memcpy (b_469 + 3993, "KCONVERTING", 11);
      memset (b_469 + 3993 + 11, 32, 22);
      memcpy (b_469 + 4026, " COPY", 5);
      memset (b_469 + 4026 + 5, 32, 28);
      memcpy (b_469 + 4059, " CORR", 5);
      memset (b_469 + 4059 + 5, 32, 28);
      memcpy (b_469 + 4092, " CORRESPONDING", 14);
      memset (b_469 + 4092 + 14, 32, 19);
      memcpy (b_469 + 4125, "ICOS", 4);
      memset (b_469 + 4125 + 4, 32, 29);
      memcpy (b_469 + 4158, "KCOUNT", 6);
      memset (b_469 + 4158 + 6, 32, 27);
      memcpy (b_469 + 4191, " CRT", 4);
      memset (b_469 + 4191 + 4, 32, 29);
      memcpy (b_469 + 4224, " CURRENCY", 9);
      memset (b_469 + 4224 + 9, 32, 24);
      memcpy (b_469 + 4257, "ICURRENT-DATE", 13);
      memset (b_469 + 4257 + 13, 32, 20);
      memcpy (b_469 + 4290, " CURSOR", 7);
      memset (b_469 + 4290 + 7, 32, 26);
      memcpy (b_469 + 4323, " CYCLE", 6);
      memset (b_469 + 4323 + 6, 32, 27);
      memcpy (b_469 + 4356, "KDATA", 5);
      memset (b_469 + 4356 + 5, 32, 28);
      memcpy (b_469 + 4389, " DATA-POINTER", 13);
      memset (b_469 + 4389 + 13, 32, 20);
      memcpy (b_469 + 4422, " DATE", 5);
      memset (b_469 + 4422 + 5, 32, 28);
      memcpy (b_469 + 4455, " DATE-COMPILED", 14);
      memset (b_469 + 4455 + 14, 32, 19);
      memcpy (b_469 + 4488, " DATE-MODIFIED", 14);
      memset (b_469 + 4488 + 14, 32, 19);
      memcpy (b_469 + 4521, "IDATE-OF-INTEGER", 16);
      memset (b_469 + 4521 + 16, 32, 17);
      memcpy (b_469 + 4554, "IDATE-TO-YYYYMMDD", 17);
      memset (b_469 + 4554 + 17, 32, 16);
      memcpy (b_469 + 4587, " DATE-WRITTEN", 13);
      memset (b_469 + 4587 + 13, 32, 20);
      memcpy (b_469 + 4620, " DAY", 4);
      memset (b_469 + 4620 + 4, 32, 29);
      memcpy (b_469 + 4653, "IDAY-OF-INTEGER", 15);
      memset (b_469 + 4653 + 15, 32, 18);
      memcpy (b_469 + 4686, " DAY-OF-WEEK", 12);
      memset (b_469 + 4686 + 12, 32, 21);
      memcpy (b_469 + 4719, "IDAY-TO-YYYYDDD", 15);
      memset (b_469 + 4719 + 15, 32, 18);
      memcpy (b_469 + 4752, " DE", 3);
      memset (b_469 + 4752 + 3, 32, 30);
      memcpy (b_469 + 4785, " DEBUGGING", 10);
      memset (b_469 + 4785 + 10, 32, 23);
      memcpy (b_469 + 4818, " DECIMAL-POINT", 14);
      memset (b_469 + 4818 + 14, 32, 19);
      memcpy (b_469 + 4851, " DECLARATIVES", 13);
      memset (b_469 + 4851 + 13, 32, 20);
      memcpy (b_469 + 4884, " DEFAULT", 8);
      memset (b_469 + 4884 + 8, 32, 25);
      memcpy (b_469 + 4917, "VDELETE", 7);
      memset (b_469 + 4917 + 7, 32, 26);
      memcpy (b_469 + 4950, " DELIMITED", 10);
      memset (b_469 + 4950 + 10, 32, 23);
      memcpy (b_469 + 4983, "KDELIMITER", 10);
      memset (b_469 + 4983 + 10, 32, 23);
      memcpy (b_469 + 5016, " DEPENDING", 10);
      memset (b_469 + 5016 + 10, 32, 23);
      memcpy (b_469 + 5049, " DESCENDING", 11);
      memset (b_469 + 5049 + 11, 32, 22);
      memcpy (b_469 + 5082, " DESTINATION", 12);
      memset (b_469 + 5082 + 12, 32, 21);
      memcpy (b_469 + 5115, " DETAIL", 7);
      memset (b_469 + 5115 + 7, 32, 26);
      memcpy (b_469 + 5148, " DISABLE", 8);
      memset (b_469 + 5148 + 8, 32, 25);
      memcpy (b_469 + 5181, " DISK", 5);
      memset (b_469 + 5181 + 5, 32, 28);
      memcpy (b_469 + 5214, "VDISPLAY", 8);
      memset (b_469 + 5214 + 8, 32, 25);
      memcpy (b_469 + 5247, "VDIVIDE", 7);
      memset (b_469 + 5247 + 7, 32, 26);
      memcpy (b_469 + 5280, "KDIVISION", 9);
      memset (b_469 + 5280 + 9, 32, 24);
      memcpy (b_469 + 5313, "KDOWN", 5);
      memset (b_469 + 5313 + 5, 32, 28);
      memcpy (b_469 + 5346, " DUPLICATES", 11);
      memset (b_469 + 5346 + 11, 32, 22);
      memcpy (b_469 + 5379, " DYNAMIC", 8);
      memset (b_469 + 5379 + 8, 32, 25);
      memcpy (b_469 + 5412, "IE", 2);
      memset (b_469 + 5412 + 2, 32, 31);
      memcpy (b_469 + 5445, " EBCDIC", 7);
      memset (b_469 + 5445 + 7, 32, 26);
      memcpy (b_469 + 5478, " EC", 3);
      memset (b_469 + 5478 + 3, 32, 30);
      memcpy (b_469 + 5511, "VELSE", 5);
      memset (b_469 + 5511 + 5, 32, 28);
      memcpy (b_469 + 5544, "KEND", 4);
      memset (b_469 + 5544 + 4, 32, 29);
      memcpy (b_469 + 5577, " END-ACCEPT", 11);
      memset (b_469 + 5577 + 11, 32, 22);
      memcpy (b_469 + 5610, " END-ADD", 8);
      memset (b_469 + 5610 + 8, 32, 25);
      memcpy (b_469 + 5643, " END-CALL", 9);
      memset (b_469 + 5643 + 9, 32, 24);
      memcpy (b_469 + 5676, " END-COMPUTE", 12);
      memset (b_469 + 5676 + 12, 32, 21);
      memcpy (b_469 + 5709, " END-DELETE", 11);
      memset (b_469 + 5709 + 11, 32, 22);
      memcpy (b_469 + 5742, " END-DISPLAY", 12);
      memset (b_469 + 5742 + 12, 32, 21);
      memcpy (b_469 + 5775, " END-DIVIDE", 11);
      memset (b_469 + 5775 + 11, 32, 22);
      memcpy (b_469 + 5808, " END-EVALUATE", 13);
      memset (b_469 + 5808 + 13, 32, 20);
      memcpy (b_469 + 5841, " END-IF", 7);
      memset (b_469 + 5841 + 7, 32, 26);
      memcpy (b_469 + 5874, " END-MULTIPLY", 13);
      memset (b_469 + 5874 + 13, 32, 20);
      memcpy (b_469 + 5907, " END-OF-PAGE", 12);
      memset (b_469 + 5907 + 12, 32, 21);
      memcpy (b_469 + 5940, " END-PERFORM", 12);
      memset (b_469 + 5940 + 12, 32, 21);
      memcpy (b_469 + 5973, " END-READ", 9);
      memset (b_469 + 5973 + 9, 32, 24);
      memcpy (b_469 + 6006, " END-RETURN", 11);
      memset (b_469 + 6006 + 11, 32, 22);
      memcpy (b_469 + 6039, " END-REWRITE", 12);
      memset (b_469 + 6039 + 12, 32, 21);
      memcpy (b_469 + 6072, " END-SEARCH", 11);
      memset (b_469 + 6072 + 11, 32, 22);
      memcpy (b_469 + 6105, " END-START", 10);
      memset (b_469 + 6105 + 10, 32, 23);
      memcpy (b_469 + 6138, " END-STRING", 11);
      memset (b_469 + 6138 + 11, 32, 22);
      memcpy (b_469 + 6171, " END-SUBTRACT", 13);
      memset (b_469 + 6171 + 13, 32, 20);
      memcpy (b_469 + 6204, " END-UNSTRING", 13);
      memset (b_469 + 6204 + 13, 32, 20);
      memcpy (b_469 + 6237, " END-WRITE", 10);
      memset (b_469 + 6237 + 10, 32, 23);
      memcpy (b_469 + 6270, "VENTRY", 6);
      memset (b_469 + 6270 + 6, 32, 27);
      memcpy (b_469 + 6303, "KENVIRONMENT", 12);
      memset (b_469 + 6303 + 12, 32, 21);
      memcpy (b_469 + 6336, " ENVIRONMENT-NAME", 17);
      memset (b_469 + 6336 + 17, 32, 16);
      memcpy (b_469 + 6369, " ENVIRONMENT-VALUE", 18);
      memset (b_469 + 6369 + 18, 32, 15);
      memcpy (b_469 + 6402, " EO", 3);
      memset (b_469 + 6402 + 3, 32, 30);
      memcpy (b_469 + 6435, " EOL", 4);
      memset (b_469 + 6435 + 4, 32, 29);
      memcpy (b_469 + 6468, " EOP", 4);
      memset (b_469 + 6468 + 4, 32, 29);
      memcpy (b_469 + 6501, " EOS", 4);
      memset (b_469 + 6501 + 4, 32, 29);
      memcpy (b_469 + 6534, " EQUAL", 6);
      memset (b_469 + 6534 + 6, 32, 27);
      memcpy (b_469 + 6567, "KEQUALS", 7);
      memset (b_469 + 6567 + 7, 32, 26);
      memcpy (b_469 + 6600, " ERASE", 6);
      memset (b_469 + 6600 + 6, 32, 27);
      memcpy (b_469 + 6633, " ERROR", 6);
      memset (b_469 + 6633 + 6, 32, 27);
      memcpy (b_469 + 6666, " ESCAPE", 7);
      memset (b_469 + 6666 + 7, 32, 26);
      memcpy (b_469 + 6699, "VEVALUATE", 9);
      memset (b_469 + 6699 + 9, 32, 24);
      memcpy (b_469 + 6732, " EXCEPTION", 10);
      memset (b_469 + 6732 + 10, 32, 23);
      memcpy (b_469 + 6765, "IEXCEPTION-FILE", 15);
      memset (b_469 + 6765 + 15, 32, 18);
      memcpy (b_469 + 6798, "IEXCEPTION-LOCATION", 19);
      memset (b_469 + 6798 + 19, 32, 14);
      memcpy (b_469 + 6831, " EXCEPTION-OBJECT", 17);
      memset (b_469 + 6831 + 17, 32, 16);
      memcpy (b_469 + 6864, "IEXCEPTION-STATEMENT", 20);
      memset (b_469 + 6864 + 20, 32, 13);
      memcpy (b_469 + 6897, "IEXCEPTION-STATUS", 17);
      memset (b_469 + 6897 + 17, 32, 16);
      memcpy (b_469 + 6930, " EXCLUSIVE", 10);
      memset (b_469 + 6930 + 10, 32, 23);
      memcpy (b_469 + 6963, "VEXIT", 5);
      memset (b_469 + 6963 + 5, 32, 28);
      memcpy (b_469 + 6996, "IEXP", 4);
      memset (b_469 + 6996 + 4, 32, 29);
      memcpy (b_469 + 7029, "IEXP10", 6);
      memset (b_469 + 7029 + 6, 32, 27);
      memcpy (b_469 + 7062, " EXTEND", 7);
      memset (b_469 + 7062 + 7, 32, 26);
      memcpy (b_469 + 7095, " EXTERNAL", 9);
      memset (b_469 + 7095 + 9, 32, 24);
      memcpy (b_469 + 7128, "IFACTORIAL", 10);
      memset (b_469 + 7128 + 10, 32, 23);
      memcpy (b_469 + 7161, " FACTORY", 8);
      memset (b_469 + 7161 + 8, 32, 25);
      memcpy (b_469 + 7194, " FALSE", 6);
      memset (b_469 + 7194 + 6, 32, 27);
      memcpy (b_469 + 7227, "KFD", 3);
      memset (b_469 + 7227 + 3, 32, 30);
      memcpy (b_469 + 7260, "KFILE", 5);
      memset (b_469 + 7260 + 5, 32, 28);
      memcpy (b_469 + 7293, " FILE-CONTROL", 13);
      memset (b_469 + 7293 + 13, 32, 20);
      memcpy (b_469 + 7326, " FILE-ID", 8);
      memset (b_469 + 7326 + 8, 32, 25);
      memcpy (b_469 + 7359, " FILLER", 7);
      memset (b_469 + 7359 + 7, 32, 26);
      memcpy (b_469 + 7392, " FINAL", 6);
      memset (b_469 + 7392 + 6, 32, 27);
      memcpy (b_469 + 7425, " FIRST", 6);
      memset (b_469 + 7425 + 6, 32, 27);
      memcpy (b_469 + 7458, " FLOAT-BINARY-16", 16);
      memset (b_469 + 7458 + 16, 32, 17);
      memcpy (b_469 + 7491, " FLOAT-BINARY-34", 16);
      memset (b_469 + 7491 + 16, 32, 17);
      memcpy (b_469 + 7524, " FLOAT-BINARY-7", 15);
      memset (b_469 + 7524 + 15, 32, 18);
      memcpy (b_469 + 7557, " FLOAT-DECIMAL-16", 17);
      memset (b_469 + 7557 + 17, 32, 16);
      memcpy (b_469 + 7590, " FLOAT-DECIMAL-34", 17);
      memset (b_469 + 7590 + 17, 32, 16);
      memcpy (b_469 + 7623, " FLOAT-EXTENDED", 15);
      memset (b_469 + 7623 + 15, 32, 18);
      memcpy (b_469 + 7656, " FLOAT-LONG", 11);
      memset (b_469 + 7656 + 11, 32, 22);
      memcpy (b_469 + 7689, " FLOAT-SHORT", 12);
      memset (b_469 + 7689 + 12, 32, 21);
      memcpy (b_469 + 7722, " FOOTING", 8);
      memset (b_469 + 7722 + 8, 32, 25);
      memcpy (b_469 + 7755, " FOR", 4);
      memset (b_469 + 7755 + 4, 32, 29);
      memcpy (b_469 + 7788, " FOREGROUND-COLOR", 17);
      memset (b_469 + 7788 + 17, 32, 16);
      memcpy (b_469 + 7821, " FOREVER", 8);
      memset (b_469 + 7821 + 8, 32, 25);
      memcpy (b_469 + 7854, " FORMAT", 7);
      memset (b_469 + 7854 + 7, 32, 26);
      memcpy (b_469 + 7887, "MFORMFEED", 9);
      memset (b_469 + 7887 + 9, 32, 24);
      memcpy (b_469 + 7920, "IFRACTION-PART", 14);
      memset (b_469 + 7920 + 14, 32, 19);
      memcpy (b_469 + 7953, "VFREE", 5);
      memset (b_469 + 7953 + 5, 32, 28);
      memcpy (b_469 + 7986, " FROM", 5);
      memset (b_469 + 7986 + 5, 32, 28);
      memcpy (b_469 + 8019, " FULL", 5);
      memset (b_469 + 8019 + 5, 32, 28);
      memcpy (b_469 + 8052, " FUNCTION", 9);
      memset (b_469 + 8052 + 9, 32, 24);
      memcpy (b_469 + 8085, " FUNCTION-ID", 12);
      memset (b_469 + 8085 + 12, 32, 21);
      memcpy (b_469 + 8118, " FUNCTION-POINTER", 17);
      memset (b_469 + 8118 + 17, 32, 16);
      memcpy (b_469 + 8151, "VGENERATE", 9);
      memset (b_469 + 8151 + 9, 32, 24);
      memcpy (b_469 + 8184, " GET", 4);
      memset (b_469 + 8184 + 4, 32, 29);
      memcpy (b_469 + 8217, "KGIVING", 7);
      memset (b_469 + 8217 + 7, 32, 26);
      memcpy (b_469 + 8250, " GLOBAL", 7);
      memset (b_469 + 8250 + 7, 32, 26);
      memcpy (b_469 + 8283, "VGO", 3);
      memset (b_469 + 8283 + 3, 32, 30);
      memcpy (b_469 + 8316, "VGOBACK", 7);
      memset (b_469 + 8316 + 7, 32, 26);
      memcpy (b_469 + 8349, " GREATER", 8);
      memset (b_469 + 8349 + 8, 32, 25);
      memcpy (b_469 + 8382, " GROUP", 6);
      memset (b_469 + 8382 + 6, 32, 27);
      memcpy (b_469 + 8415, " GROUP-USAGE", 12);
      memset (b_469 + 8415 + 12, 32, 21);
      memcpy (b_469 + 8448, " HEADING", 8);
      memset (b_469 + 8448 + 8, 32, 25);
      memcpy (b_469 + 8481, " HIGH-VALUE", 11);
      memset (b_469 + 8481 + 11, 32, 22);
      memcpy (b_469 + 8514, " HIGH-VALUES", 12);
      memset (b_469 + 8514 + 12, 32, 21);
      memcpy (b_469 + 8547, " HIGHLIGHT", 10);
      memset (b_469 + 8547 + 10, 32, 23);
      memcpy (b_469 + 8580, " I-O", 4);
      memset (b_469 + 8580 + 4, 32, 29);
      memcpy (b_469 + 8613, " I-O-CONTROL", 12);
      memset (b_469 + 8613 + 12, 32, 21);
      memcpy (b_469 + 8646, "KID", 3);
      memset (b_469 + 8646 + 3, 32, 30);
      memcpy (b_469 + 8679, "KIDENTIFICATION", 15);
      memset (b_469 + 8679 + 15, 32, 18);
      memcpy (b_469 + 8712, "VIF", 3);
      memset (b_469 + 8712 + 3, 32, 30);
      memcpy (b_469 + 8745, " IGNORE", 7);
      memset (b_469 + 8745 + 7, 32, 26);
      memcpy (b_469 + 8778, " IGNORING", 9);
      memset (b_469 + 8778 + 9, 32, 24);
      memcpy (b_469 + 8811, " IN", 3);
      memset (b_469 + 8811 + 3, 32, 30);
      memcpy (b_469 + 8844, " INDEX", 6);
      memset (b_469 + 8844 + 6, 32, 27);
      memcpy (b_469 + 8877, "KINDEXED", 8);
      memset (b_469 + 8877 + 8, 32, 25);
      memcpy (b_469 + 8910, " INDICATE", 9);
      memset (b_469 + 8910 + 9, 32, 24);
      memcpy (b_469 + 8943, " INFINITY", 9);
      memset (b_469 + 8943 + 9, 32, 24);
      memcpy (b_469 + 8976, " INHERITS", 9);
      memset (b_469 + 8976 + 9, 32, 24);
      memcpy (b_469 + 9009, " INITIAL", 8);
      memset (b_469 + 9009 + 8, 32, 25);
      memcpy (b_469 + 9042, " INITIALISED", 12);
      memset (b_469 + 9042 + 12, 32, 21);
      memcpy (b_469 + 9075, "VINITIALIZE", 11);
      memset (b_469 + 9075 + 11, 32, 22);
      memcpy (b_469 + 9108, " INITIALIZED", 12);
      memset (b_469 + 9108 + 12, 32, 21);
      memcpy (b_469 + 9141, "VINITIATE", 9);
      memset (b_469 + 9141 + 9, 32, 24);
      memcpy (b_469 + 9174, " INPUT", 6);
      memset (b_469 + 9174 + 6, 32, 27);
      memcpy (b_469 + 9207, "KINPUT-OUTPUT", 13);
      memset (b_469 + 9207 + 13, 32, 20);
      memcpy (b_469 + 9240, "VINSPECT", 8);
      memset (b_469 + 9240 + 8, 32, 25);
      memcpy (b_469 + 9273, " INSTALLATION", 13);
      memset (b_469 + 9273 + 13, 32, 20);
      memcpy (b_469 + 9306, "IINTEGER", 8);
      memset (b_469 + 9306 + 8, 32, 25);
      memcpy (b_469 + 9339, "IINTEGER-OF-DATE", 16);
      memset (b_469 + 9339 + 16, 32, 17);
      memcpy (b_469 + 9372, "IINTEGER-OF-DAY", 15);
      memset (b_469 + 9372 + 15, 32, 18);
      memcpy (b_469 + 9405, "IINTEGER-PART", 13);
      memset (b_469 + 9405 + 13, 32, 20);
      memcpy (b_469 + 9438, " INTERFACE", 10);
      memset (b_469 + 9438 + 10, 32, 23);
      memcpy (b_469 + 9471, " INTERFACE-ID", 13);
      memset (b_469 + 9471 + 13, 32, 20);
      memcpy (b_469 + 9504, "KINTO", 5);
      memset (b_469 + 9504 + 5, 32, 28);
      memcpy (b_469 + 9537, " INTRINSIC", 10);
      memset (b_469 + 9537 + 10, 32, 23);
      memcpy (b_469 + 9570, " INVALID", 8);
      memset (b_469 + 9570 + 8, 32, 25);
      memcpy (b_469 + 9603, " INVOKE", 7);
      memset (b_469 + 9603 + 7, 32, 26);
      memcpy (b_469 + 9636, " IS", 3);
      memset (b_469 + 9636 + 3, 32, 30);
      memcpy (b_469 + 9669, " JUST", 5);
      memset (b_469 + 9669 + 5, 32, 28);
      memcpy (b_469 + 9702, " JUSTIFIED", 10);
      memset (b_469 + 9702 + 10, 32, 23);
      memcpy (b_469 + 9735, " KEY", 4);
      memset (b_469 + 9735 + 4, 32, 29);
      memcpy (b_469 + 9768, " LABEL", 6);
      memset (b_469 + 9768 + 6, 32, 27);
      memcpy (b_469 + 9801, " LAST", 5);
      memset (b_469 + 9801 + 5, 32, 28);
      memcpy (b_469 + 9834, " LEADING", 8);
      memset (b_469 + 9834 + 8, 32, 25);
      memcpy (b_469 + 9867, " LEFT", 5);
      memset (b_469 + 9867 + 5, 32, 28);
      memcpy (b_469 + 9900, " LEFT-JUSTIFY", 13);
      memset (b_469 + 9900 + 13, 32, 20);
      memcpy (b_469 + 9933, "ILENGTH", 7);
      memset (b_469 + 9933 + 7, 32, 26);
      memcpy (b_469 + 9966, " LESS", 5);
      memset (b_469 + 9966 + 5, 32, 28);
      memcpy (b_469 + 9999, " LIMIT", 6);
      memset (b_469 + 9999 + 6, 32, 27);
      memcpy (b_469 + 10032, " LIMITS", 7);
      memset (b_469 + 10032 + 7, 32, 26);
      memcpy (b_469 + 10065, " LINAGE", 7);
      memset (b_469 + 10065 + 7, 32, 26);
      memcpy (b_469 + 10098, "ILINAGE-COUNTER", 15);
      memset (b_469 + 10098 + 15, 32, 18);
      memcpy (b_469 + 10131, " LINE", 5);
      memset (b_469 + 10131 + 5, 32, 28);
      memcpy (b_469 + 10164, " LINE-COUNTER", 13);
      memset (b_469 + 10164 + 13, 32, 20);
      memcpy (b_469 + 10197, " LINES", 6);
      memset (b_469 + 10197 + 6, 32, 27);
      memcpy (b_469 + 10230, "KLINKAGE", 8);
      memset (b_469 + 10230 + 8, 32, 25);
      memcpy (b_469 + 10263, "KLOCAL-STORAGE", 14);
      memset (b_469 + 10263 + 14, 32, 19);
      memcpy (b_469 + 10296, " LOCALE", 7);
      memset (b_469 + 10296 + 7, 32, 26);
      memcpy (b_469 + 10329, "ILOCALE-DATE", 12);
      memset (b_469 + 10329 + 12, 32, 21);
      memcpy (b_469 + 10362, "ILOCALE-TIME", 12);
      memset (b_469 + 10362 + 12, 32, 21);
      memcpy (b_469 + 10395, "ILOCALE-TIME-FROM-SECONDS", 25);
      memset (b_469 + 10395 + 25, 32, 8);
      memcpy (b_469 + 10428, " LOCK", 5);
      memset (b_469 + 10428 + 5, 32, 28);
      memcpy (b_469 + 10461, "ILOG", 4);
      memset (b_469 + 10461 + 4, 32, 29);
      memcpy (b_469 + 10494, "ILOG10", 6);
      memset (b_469 + 10494 + 6, 32, 27);
      memcpy (b_469 + 10527, " LOW-VALUE", 10);
      memset (b_469 + 10527 + 10, 32, 23);
      memcpy (b_469 + 10560, " LOW-VALUES", 11);
      memset (b_469 + 10560 + 11, 32, 22);
      memcpy (b_469 + 10593, " LOWER", 6);
      memset (b_469 + 10593 + 6, 32, 27);
      memcpy (b_469 + 10626, "ILOWER-CASE", 11);
      memset (b_469 + 10626 + 11, 32, 22);
      memcpy (b_469 + 10659, " LOWLIGHT", 9);
      memset (b_469 + 10659 + 9, 32, 24);
      memcpy (b_469 + 10692, " MANUAL", 7);
      memset (b_469 + 10692 + 7, 32, 26);
      memcpy (b_469 + 10725, "IMAX", 4);
      memset (b_469 + 10725 + 4, 32, 29);
      memcpy (b_469 + 10758, "IMEAN", 5);
      memset (b_469 + 10758 + 5, 32, 28);
      memcpy (b_469 + 10791, "IMEDIAN", 7);
      memset (b_469 + 10791 + 7, 32, 26);
      memcpy (b_469 + 10824, " MEMORY", 7);
      memset (b_469 + 10824 + 7, 32, 26);
      memcpy (b_469 + 10857, "VMERGE", 6);
      memset (b_469 + 10857 + 6, 32, 27);
      memcpy (b_469 + 10890, " METHOD", 7);
      memset (b_469 + 10890 + 7, 32, 26);
      memcpy (b_469 + 10923, " METHOD-ID", 10);
      memset (b_469 + 10923 + 10, 32, 23);
      memcpy (b_469 + 10956, "IMIDRANGE", 9);
      memset (b_469 + 10956 + 9, 32, 24);
      memcpy (b_469 + 10989, "IMIN", 4);
      memset (b_469 + 10989 + 4, 32, 29);
      memcpy (b_469 + 11022, " MINUS", 6);
      memset (b_469 + 11022 + 6, 32, 27);
      memcpy (b_469 + 11055, "IMOD", 4);
      memset (b_469 + 11055 + 4, 32, 29);
      memcpy (b_469 + 11088, " MODE", 5);
      memset (b_469 + 11088 + 5, 32, 28);
      memcpy (b_469 + 11121, "VMOVE", 5);
      memset (b_469 + 11121 + 5, 32, 28);
      memcpy (b_469 + 11154, " MULTIPLE", 9);
      memset (b_469 + 11154 + 9, 32, 24);
      memcpy (b_469 + 11187, "VMULTIPLY", 9);
      memset (b_469 + 11187 + 9, 32, 24);
      memcpy (b_469 + 11220, " NATIONAL", 9);
      memset (b_469 + 11220 + 9, 32, 24);
      memcpy (b_469 + 11253, " NATIONAL-EDITED", 16);
      memset (b_469 + 11253 + 16, 32, 17);
      memcpy (b_469 + 11286, " NATIVE", 7);
      memset (b_469 + 11286 + 7, 32, 26);
      memcpy (b_469 + 11319, " NEGATIVE", 9);
      memset (b_469 + 11319 + 9, 32, 24);
      memcpy (b_469 + 11352, " NESTED", 7);
      memset (b_469 + 11352 + 7, 32, 26);
      memcpy (b_469 + 11385, "VNEXT", 5);
      memset (b_469 + 11385 + 5, 32, 28);
      memcpy (b_469 + 11418, " NO", 3);
      memset (b_469 + 11418 + 3, 32, 30);
      memcpy (b_469 + 11451, " NOT", 4);
      memset (b_469 + 11451 + 4, 32, 29);
      memcpy (b_469 + 11484, " NULL", 5);
      memset (b_469 + 11484 + 5, 32, 28);
      memcpy (b_469 + 11517, " NULLS", 6);
      memset (b_469 + 11517 + 6, 32, 27);
      memcpy (b_469 + 11550, " NUMBER", 7);
      memset (b_469 + 11550 + 7, 32, 26);
      memcpy (b_469 + 11583, "INUMBER-OF-CALL-PARAMETERS", 26);
      memset (b_469 + 11583 + 26, 32, 7);
      memcpy (b_469 + 11616, " NUMBERS", 8);
      memset (b_469 + 11616 + 8, 32, 25);
      memcpy (b_469 + 11649, " NUMERIC", 8);
      memset (b_469 + 11649 + 8, 32, 25);
      memcpy (b_469 + 11682, " NUMERIC-EDITED", 15);
      memset (b_469 + 11682 + 15, 32, 18);
      memcpy (b_469 + 11715, "INUMVAL", 7);
      memset (b_469 + 11715 + 7, 32, 26);
      memcpy (b_469 + 11748, "INUMVAL-C", 9);
      memset (b_469 + 11748 + 9, 32, 24);
      memcpy (b_469 + 11781, " OBJECT", 7);
      memset (b_469 + 11781 + 7, 32, 26);
      memcpy (b_469 + 11814, " OBJECT-COMPUTER", 16);
      memset (b_469 + 11814 + 16, 32, 17);
      memcpy (b_469 + 11847, " OBJECT-REFERENCE", 17);
      memset (b_469 + 11847 + 17, 32, 16);
      memcpy (b_469 + 11880, " OCCURS", 7);
      memset (b_469 + 11880 + 7, 32, 26);
      memcpy (b_469 + 11913, " OF", 3);
      memset (b_469 + 11913 + 3, 32, 30);
      memcpy (b_469 + 11946, " OFF", 4);
      memset (b_469 + 11946 + 4, 32, 29);
      memcpy (b_469 + 11979, " OMITTED", 8);
      memset (b_469 + 11979 + 8, 32, 25);
      memcpy (b_469 + 12012, " ON", 3);
      memset (b_469 + 12012 + 3, 32, 30);
      memcpy (b_469 + 12045, " ONLY", 5);
      memset (b_469 + 12045 + 5, 32, 28);
      memcpy (b_469 + 12078, "VOPEN", 5);
      memset (b_469 + 12078 + 5, 32, 28);
      memcpy (b_469 + 12111, " OPTIONAL", 9);
      memset (b_469 + 12111 + 9, 32, 24);
      memcpy (b_469 + 12144, " OPTIONS", 8);
      memset (b_469 + 12144 + 8, 32, 25);
      memcpy (b_469 + 12177, " OR", 3);
      memset (b_469 + 12177 + 3, 32, 30);
      memcpy (b_469 + 12210, "IORD", 4);
      memset (b_469 + 12210 + 4, 32, 29);
      memcpy (b_469 + 12243, "IORD-MAX", 8);
      memset (b_469 + 12243 + 8, 32, 25);
      memcpy (b_469 + 12276, "IORD-MIN", 8);
      memset (b_469 + 12276 + 8, 32, 25);
      memcpy (b_469 + 12309, " ORDER", 6);
      memset (b_469 + 12309 + 6, 32, 27);
      memcpy (b_469 + 12342, " ORGANIZATION", 13);
      memset (b_469 + 12342 + 13, 32, 20);
      memcpy (b_469 + 12375, " OTHER", 6);
      memset (b_469 + 12375 + 6, 32, 27);
      memcpy (b_469 + 12408, " OUTPUT", 7);
      memset (b_469 + 12408 + 7, 32, 26);
      memcpy (b_469 + 12441, " OVERFLOW", 9);
      memset (b_469 + 12441 + 9, 32, 24);
      memcpy (b_469 + 12474, " OVERLINE", 9);
      memset (b_469 + 12474 + 9, 32, 24);
      memcpy (b_469 + 12507, " OVERRIDE", 9);
      memset (b_469 + 12507 + 9, 32, 24);
      memcpy (b_469 + 12540, " PACKED-DECIMAL", 15);
      memset (b_469 + 12540 + 15, 32, 18);
      memcpy (b_469 + 12573, " PADDING", 8);
      memset (b_469 + 12573 + 8, 32, 25);
      memcpy (b_469 + 12606, " PAGE", 5);
      memset (b_469 + 12606 + 5, 32, 28);
      memcpy (b_469 + 12639, " PAGE-COUNTER", 13);
      memset (b_469 + 12639 + 13, 32, 20);
      memcpy (b_469 + 12672, " PARAGRAPH", 10);
      memset (b_469 + 12672 + 10, 32, 23);
      memcpy (b_469 + 12705, "VPERFORM", 8);
      memset (b_469 + 12705 + 8, 32, 25);
      memcpy (b_469 + 12738, " PF", 3);
      memset (b_469 + 12738 + 3, 32, 30);
      memcpy (b_469 + 12771, " PH", 3);
      memset (b_469 + 12771 + 3, 32, 30);
      memcpy (b_469 + 12804, "IPI", 3);
      memset (b_469 + 12804 + 3, 32, 30);
      memcpy (b_469 + 12837, "KPIC", 4);
      memset (b_469 + 12837 + 4, 32, 29);
      memcpy (b_469 + 12870, "KPICTURE", 8);
      memset (b_469 + 12870 + 8, 32, 25);
      memcpy (b_469 + 12903, " PLUS", 5);
      memset (b_469 + 12903 + 5, 32, 28);
      memcpy (b_469 + 12936, "KPOINTER", 8);
      memset (b_469 + 12936 + 8, 32, 25);
      memcpy (b_469 + 12969, " POSITION", 9);
      memset (b_469 + 12969 + 9, 32, 24);
      memcpy (b_469 + 13002, " POSITIVE", 9);
      memset (b_469 + 13002 + 9, 32, 24);
      memcpy (b_469 + 13035, " PRESENT", 8);
      memset (b_469 + 13035 + 8, 32, 25);
      memcpy (b_469 + 13068, "IPRESENT-VALUE", 14);
      memset (b_469 + 13068 + 14, 32, 19);
      memcpy (b_469 + 13101, " PREVIOUS", 9);
      memset (b_469 + 13101 + 9, 32, 24);
      memcpy (b_469 + 13134, "MPRINTER", 8);
      memset (b_469 + 13134 + 8, 32, 25);
      memcpy (b_469 + 13167, " PRINTING", 9);
      memset (b_469 + 13167 + 9, 32, 24);
      memcpy (b_469 + 13200, "KPROCEDURE", 10);
      memset (b_469 + 13200 + 10, 32, 23);
      memcpy (b_469 + 13233, " PROCEDURE-POINTER", 18);
      memset (b_469 + 13233 + 18, 32, 15);
      memcpy (b_469 + 13266, " PROCEDURES", 11);
      memset (b_469 + 13266 + 11, 32, 22);
      memcpy (b_469 + 13299, " PROCEED", 8);
      memset (b_469 + 13299 + 8, 32, 25);
      memcpy (b_469 + 13332, " PROGRAM", 8);
      memset (b_469 + 13332 + 8, 32, 25);
      memcpy (b_469 + 13365, "KPROGRAM-ID", 11);
      memset (b_469 + 13365 + 11, 32, 22);
      memcpy (b_469 + 13398, " PROGRAM-POINTER", 16);
      memset (b_469 + 13398 + 16, 32, 17);
      memcpy (b_469 + 13431, " PROMPT", 7);
      memset (b_469 + 13431 + 7, 32, 26);
      memcpy (b_469 + 13464, " PROPERTY", 9);
      memset (b_469 + 13464 + 9, 32, 24);
      memcpy (b_469 + 13497, " PROTOTYPE", 10);
      memset (b_469 + 13497 + 10, 32, 23);
      memcpy (b_469 + 13530, " QUOTE", 6);
      memset (b_469 + 13530 + 6, 32, 27);
      memcpy (b_469 + 13563, " QUOTES", 7);
      memset (b_469 + 13563 + 7, 32, 26);
      memcpy (b_469 + 13596, " RAISE", 6);
      memset (b_469 + 13596 + 6, 32, 27);
      memcpy (b_469 + 13629, " RAISING", 8);
      memset (b_469 + 13629 + 8, 32, 25);
      memcpy (b_469 + 13662, "IRANDOM", 7);
      memset (b_469 + 13662 + 7, 32, 26);
      memcpy (b_469 + 13695, "IRANGE", 6);
      memset (b_469 + 13695 + 6, 32, 27);
      memcpy (b_469 + 13728, " RD", 3);
      memset (b_469 + 13728 + 3, 32, 30);
      memcpy (b_469 + 13761, "VREAD", 5);
      memset (b_469 + 13761 + 5, 32, 28);
      memcpy (b_469 + 13794, "VREADY", 6);
      memset (b_469 + 13794 + 6, 32, 27);
      memcpy (b_469 + 13827, " RECORD", 7);
      memset (b_469 + 13827 + 7, 32, 26);
      memcpy (b_469 + 13860, " RECORDING", 10);
      memset (b_469 + 13860 + 10, 32, 23);
      memcpy (b_469 + 13893, " RECORDS", 8);
      memset (b_469 + 13893 + 8, 32, 25);
      memcpy (b_469 + 13926, " RECURSIVE", 10);
      memset (b_469 + 13926 + 10, 32, 23);
      memcpy (b_469 + 13959, "KREDEFINES", 10);
      memset (b_469 + 13959 + 10, 32, 23);
      memcpy (b_469 + 13992, " REEL", 5);
      memset (b_469 + 13992 + 5, 32, 28);
      memcpy (b_469 + 14025, " REFERENCE", 10);
      memset (b_469 + 14025 + 10, 32, 23);
      memcpy (b_469 + 14058, " RELATIVE", 9);
      memset (b_469 + 14058 + 9, 32, 24);
      memcpy (b_469 + 14091, "VRELEASE", 8);
      memset (b_469 + 14091 + 8, 32, 25);
      memcpy (b_469 + 14124, "IREM", 4);
      memset (b_469 + 14124 + 4, 32, 29);
      memcpy (b_469 + 14157, " REMAINDER", 10);
      memset (b_469 + 14157 + 10, 32, 23);
      memcpy (b_469 + 14190, " REMARKS", 8);
      memset (b_469 + 14190 + 8, 32, 25);
      memcpy (b_469 + 14223, " REMOVAL", 8);
      memset (b_469 + 14223 + 8, 32, 25);
      memcpy (b_469 + 14256, "KRENAMES", 8);
      memset (b_469 + 14256 + 8, 32, 25);
      memcpy (b_469 + 14289, "KREPLACING", 10);
      memset (b_469 + 14289 + 10, 32, 23);
      memcpy (b_469 + 14322, "KREPORT", 7);
      memset (b_469 + 14322 + 7, 32, 26);
      memcpy (b_469 + 14355, " REPORTING", 10);
      memset (b_469 + 14355 + 10, 32, 23);
      memcpy (b_469 + 14388, " REPORTS", 8);
      memset (b_469 + 14388 + 8, 32, 25);
      memcpy (b_469 + 14421, " REPOSITORY", 11);
      memset (b_469 + 14421 + 11, 32, 22);
      memcpy (b_469 + 14454, " REPRESENTS-NOT-A-NUMBER", 24);
      memset (b_469 + 14454 + 24, 32, 9);
      memcpy (b_469 + 14487, " REQUIRED", 9);
      memset (b_469 + 14487 + 9, 32, 24);
      memcpy (b_469 + 14520, " RESERVE", 8);
      memset (b_469 + 14520 + 8, 32, 25);
      memcpy (b_469 + 14553, " RESUME", 7);
      memset (b_469 + 14553 + 7, 32, 26);
      memcpy (b_469 + 14586, " RETRY", 6);
      memset (b_469 + 14586 + 6, 32, 27);
      memcpy (b_469 + 14619, "VRETURN", 7);
      memset (b_469 + 14619 + 7, 32, 26);
      memcpy (b_469 + 14652, "IRETURN-CODE", 12);
      memset (b_469 + 14652 + 12, 32, 21);
      memcpy (b_469 + 14685, "KRETURNING", 10);
      memset (b_469 + 14685 + 10, 32, 23);
      memcpy (b_469 + 14718, "IREVERSE", 8);
      memset (b_469 + 14718 + 8, 32, 25);
      memcpy (b_469 + 14751, " REVERSE-VIDEO", 14);
      memset (b_469 + 14751 + 14, 32, 19);
      memcpy (b_469 + 14784, " REWIND", 7);
      memset (b_469 + 14784 + 7, 32, 26);
      memcpy (b_469 + 14817, "VREWRITE", 8);
      memset (b_469 + 14817 + 8, 32, 25);
      memcpy (b_469 + 14850, " RF", 3);
      memset (b_469 + 14850 + 3, 32, 30);
      memcpy (b_469 + 14883, " RH", 3);
      memset (b_469 + 14883 + 3, 32, 30);
      memcpy (b_469 + 14916, " RIGHT", 6);
      memset (b_469 + 14916 + 6, 32, 27);
      memcpy (b_469 + 14949, " RIGHT-JUSTIFY", 14);
      memset (b_469 + 14949 + 14, 32, 19);
      memcpy (b_469 + 14982, "VROLLBACK", 9);
      memset (b_469 + 14982 + 9, 32, 24);
      memcpy (b_469 + 15015, " ROUNDED", 8);
      memset (b_469 + 15015 + 8, 32, 25);
      memcpy (b_469 + 15048, " RUN", 4);
      memset (b_469 + 15048 + 4, 32, 29);
      memcpy (b_469 + 15081, " SAME", 5);
      memset (b_469 + 15081 + 5, 32, 28);
      memcpy (b_469 + 15114, "KSCREEN", 7);
      memset (b_469 + 15114 + 7, 32, 26);
      memcpy (b_469 + 15147, " SCROLL", 7);
      memset (b_469 + 15147 + 7, 32, 26);
      memcpy (b_469 + 15180, "KSD", 3);
      memset (b_469 + 15180 + 3, 32, 30);
      memcpy (b_469 + 15213, "VSEARCH", 7);
      memset (b_469 + 15213 + 7, 32, 26);
      memcpy (b_469 + 15246, "ISECONDS-FROM-FORMATTED-TIME", 28);
      memset (b_469 + 15246 + 28, 32, 5);
      memcpy (b_469 + 15279, "ISECONDS-PAST-MIDNIGHT", 22);
      memset (b_469 + 15279 + 22, 32, 11);
      memcpy (b_469 + 15312, "KSECTION", 8);
      memset (b_469 + 15312 + 8, 32, 25);
      memcpy (b_469 + 15345, " SECURE", 7);
      memset (b_469 + 15345 + 7, 32, 26);
      memcpy (b_469 + 15378, " SECURITY", 9);
      memset (b_469 + 15378 + 9, 32, 24);
      memcpy (b_469 + 15411, " SEGMENT-LIMIT", 14);
      memset (b_469 + 15411 + 14, 32, 19);
      memcpy (b_469 + 15444, " SELECT", 7);
      memset (b_469 + 15444 + 7, 32, 26);
      memcpy (b_469 + 15477, " SELF", 5);
      memset (b_469 + 15477 + 5, 32, 28);
      memcpy (b_469 + 15510, " SENTENCE", 9);
      memset (b_469 + 15510 + 9, 32, 24);
      memcpy (b_469 + 15543, " SEPARATE", 9);
      memset (b_469 + 15543 + 9, 32, 24);
      memcpy (b_469 + 15576, " SEQUENCE", 9);
      memset (b_469 + 15576 + 9, 32, 24);
      memcpy (b_469 + 15609, " SEQUENTIAL", 11);
      memset (b_469 + 15609 + 11, 32, 22);
      memcpy (b_469 + 15642, "VSET", 4);
      memset (b_469 + 15642 + 4, 32, 29);
      memcpy (b_469 + 15675, " SHARING", 8);
      memset (b_469 + 15675 + 8, 32, 25);
      memcpy (b_469 + 15708, "ISIGN", 5);
      memset (b_469 + 15708 + 5, 32, 28);
      memcpy (b_469 + 15741, " SIGNED", 7);
      memset (b_469 + 15741 + 7, 32, 26);
      memcpy (b_469 + 15774, " SIGNED-INT", 11);
      memset (b_469 + 15774 + 11, 32, 22);
      memcpy (b_469 + 15807, " SIGNED-LONG", 12);
      memset (b_469 + 15807 + 12, 32, 21);
      memcpy (b_469 + 15840, " SIGNED-SHORT", 13);
      memset (b_469 + 15840 + 13, 32, 20);
      memcpy (b_469 + 15873, "ISIN", 4);
      memset (b_469 + 15873 + 4, 32, 29);
      memcpy (b_469 + 15906, " SIZE", 5);
      memset (b_469 + 15906 + 5, 32, 28);
      memcpy (b_469 + 15939, "VSORT", 5);
      memset (b_469 + 15939 + 5, 32, 28);
      memcpy (b_469 + 15972, " SORT-MERGE", 11);
      memset (b_469 + 15972 + 11, 32, 22);
      memcpy (b_469 + 16005, "ISORT-RETURN", 12);
      memset (b_469 + 16005 + 12, 32, 21);
      memcpy (b_469 + 16038, " SOURCE", 7);
      memset (b_469 + 16038 + 7, 32, 26);
      memcpy (b_469 + 16071, " SOURCE-COMPUTER", 16);
      memset (b_469 + 16071 + 16, 32, 17);
      memcpy (b_469 + 16104, " SOURCES", 8);
      memset (b_469 + 16104 + 8, 32, 25);
      memcpy (b_469 + 16137, " SPACE", 6);
      memset (b_469 + 16137 + 6, 32, 27);
      memcpy (b_469 + 16170, " SPACE-FILL", 11);
      memset (b_469 + 16170 + 11, 32, 22);
      memcpy (b_469 + 16203, " SPACES", 7);
      memset (b_469 + 16203 + 7, 32, 26);
      memcpy (b_469 + 16236, " SPECIAL-NAMES", 14);
      memset (b_469 + 16236 + 14, 32, 19);
      memcpy (b_469 + 16269, "ISQRT", 5);
      memset (b_469 + 16269 + 5, 32, 28);
      memcpy (b_469 + 16302, " STANDARD", 9);
      memset (b_469 + 16302 + 9, 32, 24);
      memcpy (b_469 + 16335, " STANDARD-1", 11);
      memset (b_469 + 16335 + 11, 32, 22);
      memcpy (b_469 + 16368, " STANDARD-2", 11);
      memset (b_469 + 16368 + 11, 32, 22);
      memcpy (b_469 + 16401, "ISTANDARD-DEVIATION", 19);
      memset (b_469 + 16401 + 19, 32, 14);
      memcpy (b_469 + 16434, "VSTART", 6);
      memset (b_469 + 16434 + 6, 32, 27);
      memcpy (b_469 + 16467, " STATUS", 7);
      memset (b_469 + 16467 + 7, 32, 26);
      memcpy (b_469 + 16500, "VSTOP", 5);
      memset (b_469 + 16500 + 5, 32, 28);
      memcpy (b_469 + 16533, "ISTORED-CHAR-LENGTH", 19);
      memset (b_469 + 16533 + 19, 32, 14);
      memcpy (b_469 + 16566, "VSTRING", 7);
      memset (b_469 + 16566 + 7, 32, 26);
      memcpy (b_469 + 16599, "ISUBSTITUTE", 11);
      memset (b_469 + 16599 + 11, 32, 22);
      memcpy (b_469 + 16632, "ISUBSTITUTE-CASE", 16);
      memset (b_469 + 16632 + 16, 32, 17);
      memcpy (b_469 + 16665, "VSUBTRACT", 9);
      memset (b_469 + 16665 + 9, 32, 24);
      memcpy (b_469 + 16698, "ISUM", 4);
      memset (b_469 + 16698 + 4, 32, 29);
      memcpy (b_469 + 16731, " SUPER", 6);
      memset (b_469 + 16731 + 6, 32, 27);
      memcpy (b_469 + 16764, "VSUPPRESS", 9);
      memset (b_469 + 16764 + 9, 32, 24);
      memcpy (b_469 + 16797, "MSWITCH-1", 9);
      memset (b_469 + 16797 + 9, 32, 24);
      memcpy (b_469 + 16830, "MSWITCH-2", 9);
      memset (b_469 + 16830 + 9, 32, 24);
      memcpy (b_469 + 16863, "MSWITCH-3", 9);
      memset (b_469 + 16863 + 9, 32, 24);
      memcpy (b_469 + 16896, "MSWITCH-4", 9);
      memset (b_469 + 16896 + 9, 32, 24);
      memcpy (b_469 + 16929, "MSWITCH-5", 9);
      memset (b_469 + 16929 + 9, 32, 24);
      memcpy (b_469 + 16962, "MSWITCH-6", 9);
      memset (b_469 + 16962 + 9, 32, 24);
      memcpy (b_469 + 16995, "MSWITCH-7", 9);
      memset (b_469 + 16995 + 9, 32, 24);
      memcpy (b_469 + 17028, "MSWITCH-8", 9);
      memset (b_469 + 17028 + 9, 32, 24);
      memcpy (b_469 + 17061, " SYMBOLIC", 9);
      memset (b_469 + 17061 + 9, 32, 24);
      memcpy (b_469 + 17094, " SYNC", 5);
      memset (b_469 + 17094 + 5, 32, 28);
      memcpy (b_469 + 17127, " SYNCHRONIZED", 13);
      memset (b_469 + 17127 + 13, 32, 20);
      memcpy (b_469 + 17160, "MSYSERR", 7);
      memset (b_469 + 17160 + 7, 32, 26);
      memcpy (b_469 + 17193, "MSYSIN", 6);
      memset (b_469 + 17193 + 6, 32, 27);
      memcpy (b_469 + 17226, "MSYSIPT", 7);
      memset (b_469 + 17226 + 7, 32, 26);
      memcpy (b_469 + 17259, "MSYSLIST", 8);
      memset (b_469 + 17259 + 8, 32, 25);
      memcpy (b_469 + 17292, "MSYSLST", 7);
      memset (b_469 + 17292 + 7, 32, 26);
      memcpy (b_469 + 17325, "MSYSOUT", 7);
      memset (b_469 + 17325 + 7, 32, 26);
      memcpy (b_469 + 17358, " SYSTEM-DEFAULT", 15);
      memset (b_469 + 17358 + 15, 32, 18);
      memcpy (b_469 + 17391, " TABLE", 6);
      memset (b_469 + 17391 + 6, 32, 27);
      memcpy (b_469 + 17424, "KTALLYING", 9);
      memset (b_469 + 17424 + 9, 32, 24);
      memcpy (b_469 + 17457, "ITAN", 4);
      memset (b_469 + 17457 + 4, 32, 29);
      memcpy (b_469 + 17490, " TAPE", 5);
      memset (b_469 + 17490 + 5, 32, 28);
      memcpy (b_469 + 17523, "VTERMINATE", 10);
      memset (b_469 + 17523 + 10, 32, 23);
      memcpy (b_469 + 17556, " TEST", 5);
      memset (b_469 + 17556 + 5, 32, 28);
      memcpy (b_469 + 17589, "ITEST-DATE-YYYYMMDD", 19);
      memset (b_469 + 17589 + 19, 32, 14);
      memcpy (b_469 + 17622, "ITEST-DAY-YYYYDDD", 17);
      memset (b_469 + 17622 + 17, 32, 16);
      memcpy (b_469 + 17655, " THAN", 5);
      memset (b_469 + 17655 + 5, 32, 28);
      memcpy (b_469 + 17688, " THEN", 5);
      memset (b_469 + 17688 + 5, 32, 28);
      memcpy (b_469 + 17721, " THROUGH", 8);
      memset (b_469 + 17721 + 8, 32, 25);
      memcpy (b_469 + 17754, " THRU", 5);
      memset (b_469 + 17754 + 5, 32, 28);
      memcpy (b_469 + 17787, " TIME", 5);
      memset (b_469 + 17787 + 5, 32, 28);
      memcpy (b_469 + 17820, " TIMES", 6);
      memset (b_469 + 17820 + 6, 32, 27);
      memcpy (b_469 + 17853, "KTO", 3);
      memset (b_469 + 17853 + 3, 32, 30);
      memcpy (b_469 + 17886, " TOP", 4);
      memset (b_469 + 17886 + 4, 32, 29);
      memcpy (b_469 + 17919, " TRAILING", 9);
      memset (b_469 + 17919 + 9, 32, 24);
      memcpy (b_469 + 17952, " TRAILING-SIGN", 14);
      memset (b_469 + 17952 + 14, 32, 19);
      memcpy (b_469 + 17985, "VTRANSFORM", 10);
      memset (b_469 + 17985 + 10, 32, 23);
      memcpy (b_469 + 18018, "ITRIM", 5);
      memset (b_469 + 18018 + 5, 32, 28);
      memcpy (b_469 + 18051, " TRUE", 5);
      memset (b_469 + 18051 + 5, 32, 28);
      memcpy (b_469 + 18084, " TYPE", 5);
      memset (b_469 + 18084 + 5, 32, 28);
      memcpy (b_469 + 18117, " TYPEDEF", 8);
      memset (b_469 + 18117 + 8, 32, 25);
      memcpy (b_469 + 18150, " UNDERLINE", 10);
      memset (b_469 + 18150 + 10, 32, 23);
      memcpy (b_469 + 18183, " UNIT", 5);
      memset (b_469 + 18183 + 5, 32, 28);
      memcpy (b_469 + 18216, " UNIVERSAL", 10);
      memset (b_469 + 18216 + 10, 32, 23);
      memcpy (b_469 + 18249, "VUNLOCK", 7);
      memset (b_469 + 18249 + 7, 32, 26);
      memcpy (b_469 + 18282, " UNSIGNED", 9);
      memset (b_469 + 18282 + 9, 32, 24);
      memcpy (b_469 + 18315, " UNSIGNED-INT", 13);
      memset (b_469 + 18315 + 13, 32, 20);
      memcpy (b_469 + 18348, " UNSIGNED-LONG", 14);
      memset (b_469 + 18348 + 14, 32, 19);
      memcpy (b_469 + 18381, " UNSIGNED-SHORT", 15);
      memset (b_469 + 18381 + 15, 32, 18);
      memcpy (b_469 + 18414, "VUNSTRING", 9);
      memset (b_469 + 18414 + 9, 32, 24);
      memcpy (b_469 + 18447, " UNTIL", 6);
      memset (b_469 + 18447 + 6, 32, 27);
      memcpy (b_469 + 18480, "KUP", 3);
      memset (b_469 + 18480 + 3, 32, 30);
      memcpy (b_469 + 18513, " UPDATE", 7);
      memset (b_469 + 18513 + 7, 32, 26);
      memcpy (b_469 + 18546, " UPON", 5);
      memset (b_469 + 18546 + 5, 32, 28);
      memcpy (b_469 + 18579, " UPPER", 6);
      memset (b_469 + 18579 + 6, 32, 27);
      memcpy (b_469 + 18612, "IUPPER-CASE", 11);
      memset (b_469 + 18612 + 11, 32, 22);
      memcpy (b_469 + 18645, " USAGE", 6);
      memset (b_469 + 18645 + 6, 32, 27);
      memcpy (b_469 + 18678, "VUSE", 4);
      memset (b_469 + 18678 + 4, 32, 29);
      memcpy (b_469 + 18711, " USER-DEFAULT", 13);
      memset (b_469 + 18711 + 13, 32, 20);
      memcpy (b_469 + 18744, "KUSING", 6);
      memset (b_469 + 18744 + 6, 32, 27);
      memcpy (b_469 + 18777, " VAL-STATUS", 11);
      memset (b_469 + 18777 + 11, 32, 22);
      memcpy (b_469 + 18810, " VALID", 6);
      memset (b_469 + 18810 + 6, 32, 27);
      memcpy (b_469 + 18843, " VALIDATE", 9);
      memset (b_469 + 18843 + 9, 32, 24);
      memcpy (b_469 + 18876, " VALIDATE-STATUS", 16);
      memset (b_469 + 18876 + 16, 32, 17);
      memcpy (b_469 + 18909, " VALUE", 6);
      memset (b_469 + 18909 + 6, 32, 27);
      memcpy (b_469 + 18942, " VALUES", 7);
      memset (b_469 + 18942 + 7, 32, 26);
      memcpy (b_469 + 18975, "IVARIANCE", 9);
      memset (b_469 + 18975 + 9, 32, 24);
      memcpy (b_469 + 19008, "KVARYING", 8);
      memset (b_469 + 19008 + 8, 32, 25);
      memcpy (b_469 + 19041, " WAIT", 5);
      memset (b_469 + 19041 + 5, 32, 28);
      memcpy (b_469 + 19074, "VWHEN", 5);
      memset (b_469 + 19074 + 5, 32, 28);
      memcpy (b_469 + 19107, "IWHEN-COMPILED", 14);
      memset (b_469 + 19107 + 14, 32, 19);
      memcpy (b_469 + 19140, " WITH", 5);
      memset (b_469 + 19140 + 5, 32, 28);
      memcpy (b_469 + 19173, " WORDS", 6);
      memset (b_469 + 19173 + 6, 32, 27);
      memcpy (b_469 + 19206, "KWORKING-STORAGE", 16);
      memset (b_469 + 19206 + 16, 32, 17);
      memcpy (b_469 + 19239, "VWRITE", 6);
      memset (b_469 + 19239 + 6, 32, 27);
      memcpy (b_469 + 19272, "IYEAR-TO-YYYY", 13);
      memset (b_469 + 19272 + 13, 32, 20);
      memcpy (b_469 + 19305, " YYYYDDD", 8);
      memset (b_469 + 19305 + 8, 32, 25);
      memcpy (b_469 + 19338, " YYYYMMDD", 9);
      memset (b_469 + 19338 + 9, 32, 24);
      memcpy (b_469 + 19371, " ZERO", 5);
      memset (b_469 + 19371 + 5, 32, 28);
      memcpy (b_469 + 19404, " ZERO-FILL", 10);
      memset (b_469 + 19404 + 10, 32, 23);
      memcpy (b_469 + 19437, " ZEROES", 7);
      memset (b_469 + 19437 + 7, 32, 26);
      memcpy (b_469 + 19470, " ZEROS", 6);
      memset (b_469 + 19470 + 6, 32, 27);
      memset (b_1066, 32, 15);
      memset (b_1067, 32, 32);
      memset (b_1068, 48, 6);
      memset (b_1069, 0, 4);
      memset (b_1070, 32, 2);
      memset (b_1070 + 2, 48, 6);
      memset (b_1070 + 8, 32, 140);
      memset (b_1105, 0, 4);
      memset (b_1106, 48, 8);

      if (!h_EXPAND_CODE)
      {
        h_EXPAND_CODE = cob_malloc (sizeof(cob_file));
      }
      h_EXPAND_CODE->select_name = (const char *)"Expand-Code";
      h_EXPAND_CODE->file_status = h_EXPAND_CODE_status;
      memset (h_EXPAND_CODE_status, '0', 2);
      h_EXPAND_CODE->assign = &f_431;
      h_EXPAND_CODE->record = &f_389;
      h_EXPAND_CODE->record_size = NULL;
      h_EXPAND_CODE->record_min = 0;
      h_EXPAND_CODE->record_max = 257;
      h_EXPAND_CODE->nkeys = 0;
      h_EXPAND_CODE->keys = NULL;
      h_EXPAND_CODE->file = NULL;
      h_EXPAND_CODE->organization = 1;
      h_EXPAND_CODE->access_mode = 1;
      h_EXPAND_CODE->lock_mode = 0;
      h_EXPAND_CODE->open_mode = 0;
      h_EXPAND_CODE->flag_optional = 0;
      h_EXPAND_CODE->last_open_mode = 0;
      h_EXPAND_CODE->special = 0;
      h_EXPAND_CODE->flag_nonexistent = 0;
      h_EXPAND_CODE->flag_end_of_file = 0;
      h_EXPAND_CODE->flag_begin_of_file = 0;
      h_EXPAND_CODE->flag_first_read = 0;
      h_EXPAND_CODE->flag_read_done = 0;
      h_EXPAND_CODE->flag_select_features = 0;
      h_EXPAND_CODE->flag_needs_nl = 0;
      h_EXPAND_CODE->flag_needs_top = 0;
      h_EXPAND_CODE->file_version = 0;
      if (!h_REPORT_FILE)
      {
        h_REPORT_FILE = cob_malloc (sizeof(cob_file));
      }
      h_REPORT_FILE->select_name = (const char *)"Report-File";
      h_REPORT_FILE->file_status = h_REPORT_FILE_status;
      memset (h_REPORT_FILE_status, '0', 2);
      h_REPORT_FILE->assign = &f_468;
      h_REPORT_FILE->record = &f_391;
      h_REPORT_FILE->record_size = NULL;
      h_REPORT_FILE->record_min = 0;
      h_REPORT_FILE->record_max = 135;
      h_REPORT_FILE->nkeys = 0;
      h_REPORT_FILE->keys = NULL;
      h_REPORT_FILE->file = NULL;
      h_REPORT_FILE->organization = 1;
      h_REPORT_FILE->access_mode = 1;
      h_REPORT_FILE->lock_mode = 0;
      h_REPORT_FILE->open_mode = 0;
      h_REPORT_FILE->flag_optional = 0;
      h_REPORT_FILE->last_open_mode = 0;
      h_REPORT_FILE->special = 0;
      h_REPORT_FILE->flag_nonexistent = 0;
      h_REPORT_FILE->flag_end_of_file = 0;
      h_REPORT_FILE->flag_begin_of_file = 0;
      h_REPORT_FILE->flag_first_read = 0;
      h_REPORT_FILE->flag_read_done = 0;
      h_REPORT_FILE->flag_select_features = 0;
      h_REPORT_FILE->flag_needs_nl = 0;
      h_REPORT_FILE->flag_needs_top = 0;
      h_REPORT_FILE->file_version = 0;
      if (!h_SORT_FILE)
      {
        h_SORT_FILE = cob_malloc (sizeof(cob_file));
      }
      h_SORT_FILE->select_name = (const char *)"Sort-File";
      h_SORT_FILE->file_status = h_SORT_FILE_status;
      memset (h_SORT_FILE_status, '0', 2);
      h_SORT_FILE->assign = &c_174;
      h_SORT_FILE->record = &f_401;
      h_SORT_FILE->record_size = NULL;
      h_SORT_FILE->record_min = 107;
      h_SORT_FILE->record_max = 107;
      h_SORT_FILE->nkeys = 0;
      h_SORT_FILE->keys = NULL;
      h_SORT_FILE->file = NULL;
      h_SORT_FILE->organization = 4;
      h_SORT_FILE->access_mode = 1;
      h_SORT_FILE->lock_mode = 0;
      h_SORT_FILE->open_mode = 0;
      h_SORT_FILE->flag_optional = 0;
      h_SORT_FILE->last_open_mode = 0;
      h_SORT_FILE->special = 0;
      h_SORT_FILE->flag_nonexistent = 0;
      h_SORT_FILE->flag_end_of_file = 0;
      h_SORT_FILE->flag_begin_of_file = 0;
      h_SORT_FILE->flag_first_read = 0;
      h_SORT_FILE->flag_read_done = 0;
      h_SORT_FILE->flag_select_features = 0;
      h_SORT_FILE->flag_needs_nl = 0;
      h_SORT_FILE->flag_needs_top = 0;
      h_SORT_FILE->file_version = 0;
      if (!h_SOURCE_CODE)
      {
        h_SOURCE_CODE = cob_malloc (sizeof(cob_file));
      }
      h_SOURCE_CODE->select_name = (const char *)"Source-Code";
      h_SOURCE_CODE->file_status = h_SOURCE_CODE_status;
      memset (h_SOURCE_CODE_status, '0', 2);
      h_SOURCE_CODE->assign = (f_1109.data = b_1109, &f_1109);
      h_SOURCE_CODE->record = &f_408;
      h_SOURCE_CODE->record_size = NULL;
      h_SOURCE_CODE->record_min = 0;
      h_SOURCE_CODE->record_max = 256;
      h_SOURCE_CODE->nkeys = 0;
      h_SOURCE_CODE->keys = NULL;
      h_SOURCE_CODE->file = NULL;
      h_SOURCE_CODE->organization = 1;
      h_SOURCE_CODE->access_mode = 1;
      h_SOURCE_CODE->lock_mode = 0;
      h_SOURCE_CODE->open_mode = 0;
      h_SOURCE_CODE->flag_optional = 0;
      h_SOURCE_CODE->last_open_mode = 0;
      h_SOURCE_CODE->special = 0;
      h_SOURCE_CODE->flag_nonexistent = 0;
      h_SOURCE_CODE->flag_end_of_file = 0;
      h_SOURCE_CODE->flag_begin_of_file = 0;
      h_SOURCE_CODE->flag_first_read = 0;
      h_SOURCE_CODE->flag_read_done = 0;
      h_SOURCE_CODE->flag_select_features = 0;
      h_SOURCE_CODE->flag_needs_nl = 0;
      h_SOURCE_CODE->flag_needs_top = 0;
      h_SOURCE_CODE->file_version = 0;

      initialized = 1;
    }

  cob_save_call_params = cob_call_params;

  /* Entry dispatch */
  goto l_70;

  /* PROCEDURE DIVISION */

  /* Entry LISTING */

  l_70:;

  /* 000-Main SECTION */

  /* 001-Init */

  /* OCic.cbl:2598: PERFORM */
  {
    /* PERFORM 100-Initialization */
    frame_ptr++;
    frame_ptr->perform_through = 73;
    frame_ptr->return_address = &&l_168;
    goto l_73;
    l_168:
    frame_ptr--;
  }
  /* OCic.cbl:2599: PERFORM */
  {
    /* PERFORM 200-Execute-cobc */
    frame_ptr++;
    frame_ptr->perform_through = 75;
    frame_ptr->return_address = &&l_169;
    goto l_75;
    l_169:
    frame_ptr--;
  }
  /* OCic.cbl:2600: OPEN */
  {
    cob_exception_code = 0;
    {
      cob_open (h_REPORT_FILE, 2, 1, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_170;
        goto l_1;
        l_170:
        frame_ptr--;
      }
  }
  /* OCic.cbl:2601: IF */
  {
    if (((int)(int)(*(b_1107) - ' ') != 0))
      {
        /* OCic.cbl:2602: PERFORM */
        {
          /* PERFORM 500-Produce-Source-Listing */
          frame_ptr++;
          frame_ptr->perform_through = 125;
          frame_ptr->return_address = &&l_171;
          goto l_125;
          l_171:
          frame_ptr--;
        }
      }
  }
  /* OCic.cbl:2604: IF */
  {
    if (((int)(int)(*(b_1108) - ' ') != 0))
      {
        /* OCic.cbl:2605: SORT */
        {
          cob_file_sort_init (h_SORT_FILE, 3, 0, b_380, NULL);
          cob_file_sort_init_key (h_SORT_FILE, 0, &f_393, 0);
          cob_file_sort_init_key (h_SORT_FILE, 0, &f_394, 15);
          cob_file_sort_init_key (h_SORT_FILE, 0, &f_399, 100);
          /* PERFORM 300-Tokenize-Source */
          frame_ptr++;
          frame_ptr->perform_through = 78;
          frame_ptr->return_address = &&l_172;
          goto l_78;
          l_172:
          frame_ptr--;
          /* PERFORM 400-Produce-Xref-Listing */
          frame_ptr++;
          frame_ptr->perform_through = 118;
          frame_ptr->return_address = &&l_173;
          goto l_118;
          l_173:
          frame_ptr--;
          cob_file_sort_close (h_SORT_FILE);
        }
      }
  }
  /* OCic.cbl:2612: CLOSE */
  {
    cob_exception_code = 0;
    {
      cob_close (h_REPORT_FILE, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_174;
        goto l_1;
        l_174:
        frame_ptr--;
      }
  }
  /* OCic.cbl:2613: GOBACK */
  {
    goto exit_program;
  }

  /* 100-Initialization SECTION */

  l_73:;

  /* 101-Establish-Working-Env */

  /* OCic.cbl:2621: MOVE */
  {
    cob_move (cob_intr_trim (0, 0, (f_1109.data = b_1109, &f_1109), 1), (f_1109.data = b_1109, &f_1109));
  }
  /* OCic.cbl:2622: ACCEPT */
  {
    cob_get_environment (&c_129, &f_430);
  }
  /* OCic.cbl:2625: ACCEPT */
  {
    cob_get_environment (&c_175, &f_462);
  }
  /* OCic.cbl:2628: INSPECT */
  {
    cob_inspect_init ((f_1109.data = b_1109, &f_1109), 1);
    cob_inspect_start ();
    cob_inspect_all (&c_133, &c_176);
    cob_inspect_finish ();
  }
  /* OCic.cbl:2629: INSPECT */
  {
    cob_inspect_init (&f_430, 1);
    cob_inspect_start ();
    cob_inspect_all (&c_133, &c_176);
    cob_inspect_finish ();
  }
  /* OCic.cbl:2630: MOVE */
  {
    memcpy (b_467, b_1109, 256);
  }
  /* OCic.cbl:2631: MOVE */
  {
    memcpy (b_452, b_467, 135);
  }
  /* OCic.cbl:2632: CALL */
  {
    {

      module.cob_procedure_parameters[0] = &f_452;
      module.cob_procedure_parameters[1] = &c_177;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      module.cob_procedure_parameters[5] = NULL;
      cob_call_params = 2;
      (*(int *) (b_379)) = cob_acuw_justify (b_452, (unsigned char *)"Right");
    }
  }
  /* OCic.cbl:2635: MOVE */
  {
    cob_move (cob_intr_length (cob_intr_trim (0, 0, (f_1109.data = b_1109, &f_1109), 2)), &f_458);
  }
  /* OCic.cbl:2636: MOVE */
  {
    (*(int *)(b_459)) = 0;
  }
  /* OCic.cbl:2637: PERFORM */
  {
    while (1)
      {
        if ((((int)(int)(*(b_1109 + ((*(int *)(b_458)) - 1)) - 47) == 0) || ((int)cob_cmp_s32_binary (b_458, 0) == 0)))
          break;
        {
          /* OCic.cbl:2639: SUBTRACT */
          {
            (*(int *)(b_458)) = ((*(int *)(b_458)) - 1);
          }
          /* OCic.cbl:2640: ADD */
          {
            (*(int *)(b_459)) = ((*(int *)(b_459)) + 1);
          }
        }
      }
  }
  /* OCic.cbl:2642: UNSTRING */
  {
    cob_unstring_init ((f0.size = (*(int *)(b_459)), f0.data = b_1109 + (((*(int *)(b_458)) + 1) - 1), f0.attr = &a_2, &f0), 0, 1);
    cob_unstring_delimited (&c_140, 0);
    cob_unstring_into (&f_432, 0, 0);
    cob_unstring_into (&f_429, 0, 0);
    cob_unstring_finish ();
  }
  /* OCic.cbl:2645: STRING */
  {
    cob_string_init (&f_431, 0);
    cob_string_delimited (0);
    cob_string_append (cob_intr_trim (0, 0, &f_430, 2));
    cob_string_append (&c_133);
    cob_string_append (cob_intr_trim (0, 0, &f_432, 2));
    cob_string_append (&c_178);
    cob_string_finish ();
  }
  /* OCic.cbl:2652: STRING */
  {
    cob_string_init (&f_468, 0);
    cob_string_delimited (0);
    cob_string_append ((f0.size = (*(int *)(b_458)), f0.data = b_467 + 0, f0.attr = &a_2, &f0));
    cob_string_append (cob_intr_trim (0, 0, &f_432, 2));
    cob_string_append (&c_161);
    cob_string_finish ();
  }
  /* OCic.cbl:2658: IF */
  {
    if (((int)cob_cmp (&f_462, &cob_space) != 0))
      {
        /* OCic.cbl:2659: MOVE */
        {
          cob_move (cob_intr_numval (&f_462), &f_461);
        }
      }
    else
      {
        /* OCic.cbl:2661: MOVE */
        {
          (*(int *)(b_461)) = 60;
        }
      }
  }
  /* OCic.cbl:2663: ACCEPT */
  {
    cob_accept_date_yyyymmdd (&f_1106);
  }
  /* OCic.cbl:2666: MOVE */
  {
    cob_move (&f_1106, &f_451);
    cob_move (&f_1106, &f_448);
  }
  /* OCic.cbl:2668: MOVE */
  {
    memcpy (b_1070 + 8, "????????????...", 15);
  }
  /* OCic.cbl:2669: MOVE */
  {
    memset (b_1070 + 102, 32, 12);
    memset (b_457, 32, 100);
  }
  /* OCic.cbl:2671: MOVE */
  {
    *(b_433 + 1) = 89;
  }

  if (frame_ptr->perform_through == 73)
    goto *frame_ptr->return_address;

  /* 200-Execute-cobc SECTION */

  l_75:;

  /* 201-Build-Cmd */

  /* OCic.cbl:2676: STRING */
  {
    cob_string_init (&f_410, 0);
    cob_string_delimited (0);
    cob_string_append (&c_179);
    cob_string_append (cob_intr_trim (0, 0, &f_467, 2));
    cob_string_append (&c_180);
    cob_string_append (cob_intr_trim (0, 0, &f_431, 2));
    cob_string_finish ();
  }
  /* OCic.cbl:2683: CALL */
  {
    {

      module.cob_procedure_parameters[0] = &f_410;
      module.cob_procedure_parameters[1] = NULL;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      cob_call_params = 1;
      (*(int *) (b_379)) = SYSTEM (b_410);
    }
  }
  /* OCic.cbl:2686: IF */
  {
    if (((int)((*(int *) (b_379)) - 0) != 0))
      {
        /* OCic.cbl:2687: DISPLAY */
        {
          cob_display (1, 1, 1, &c_181);
        }
        /* OCic.cbl:2691: GOBACK */
        {
          goto exit_program;
        }
      }
  }

  /* 209-Exit */

  /* OCic.cbl:2696: EXIT */

  if (frame_ptr->perform_through == 75)
    goto *frame_ptr->return_address;

  /* 300-Tokenize-Source SECTION */

  l_78:;

  /* 301-Driver */

  /* OCic.cbl:2701: OPEN */
  {
    cob_exception_code = 0;
    {
      cob_open (h_EXPAND_CODE, 1, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_175;
        goto l_1;
        l_175:
        frame_ptr--;
      }
  }
  /* OCic.cbl:2702: MOVE */
  {
    memset (b_389, 32, 257);
  }
  /* OCic.cbl:2703: MOVE */
  {
    (*(int *)(b_1069)) = 256;
  }
  /* OCic.cbl:2704: MOVE */
  {
    (*(int *)(b_463)) = 0;
    memset (b_1070 + 2, 48, 6);
  }
  /* OCic.cbl:2706: MOVE */
  {
    *(b_1070 + 1) = 63;
  }
  /* OCic.cbl:2707: MOVE */
  {
    *(b_433 + 6) = 78;
  }
  /* OCic.cbl:2708: PERFORM */
  {
    while (1)
      {
        {
          /* OCic.cbl:2709: PERFORM */
          {
            /* PERFORM 310-Get-Token */
            frame_ptr++;
            frame_ptr->perform_through = 82;
            frame_ptr->return_address = &&l_176;
            goto l_82;
            l_176:
            frame_ptr--;
          }
          /* OCic.cbl:2710: IF */
          {
            if (((int)(int)(*(b_1070 + 147) - 255) == 0))
              {
                /* OCic.cbl:2711: EXIT */
                {
                  goto l_80;
                }
              }
          }
          /* OCic.cbl:2713: MOVE */
          {
            cob_move (cob_intr_upper_case (0, 0, &f_1091), &f_1092);
          }
          /* OCic.cbl:2715: IF */
          {
            if (((int)(int)(*(b_1070 + 147) - 86) == 0))
              {
                /* OCic.cbl:2716: MOVE */
                {
                  memcpy (b_1070 + 102, b_1070 + 70, 12);
                  memcpy (b_1070 + 115, b_1070 + 70, 32);
                }
                /* OCic.cbl:2718: IF */
                {
                  if (((int)cob_cmp (&f_457, &cob_space) != 0))
                    {
                      /* OCic.cbl:2719: MOVE */
                      {
                        cob_move (&f_457, &f_392);
                      }
                      /* OCic.cbl:2720: MOVE */
                      {
                        memset (b_457, 32, 100);
                      }
                      /* OCic.cbl:2721: RELEASE */
                      cob_exception_code = 0;
                      {
                        cob_file_release (h_SORT_FILE);
                      }
                      if (unlikely(cob_exception_code != 0))
                        {
                          /* PERFORM Default Error Handler */
                          frame_ptr++;
                          frame_ptr->perform_through = 1;
                          frame_ptr->return_address = &&l_177;
                          goto l_1;
                          l_177:
                          frame_ptr--;
                        }
                    }
                }
              }
          }
          /* OCic.cbl:2724: EVALUATE */
          {
            if ((((int)(int)(*(b_1070 + 1) - 73) == 0) || ((int)(int)(*(b_1070 + 1) - 63) == 0)))
              {
                /* OCic.cbl:2726: PERFORM */
                {
                  /* PERFORM 320-IDENTIFICATION-DIVISION */
                  frame_ptr++;
                  frame_ptr->perform_through = 88;
                  frame_ptr->return_address = &&l_178;
                  goto l_88;
                  l_178:
                  frame_ptr--;
                }
              }
            else
              if (((int)(int)(*(b_1070 + 1) - 69) == 0))
                {
                  /* OCic.cbl:2728: PERFORM */
                  {
                    /* PERFORM 330-ENVIRONMENT-DIVISION */
                    frame_ptr++;
                    frame_ptr->perform_through = 90;
                    frame_ptr->return_address = &&l_179;
                    goto l_90;
                    l_179:
                    frame_ptr--;
                  }
                }
              else
                if (((int)(int)(*(b_1070 + 1) - 68) == 0))
                  {
                    /* OCic.cbl:2730: PERFORM */
                    {
                      /* PERFORM 340-DATA-DIVISION */
                      frame_ptr++;
                      frame_ptr->perform_through = 92;
                      frame_ptr->return_address = &&l_180;
                      goto l_92;
                      l_180:
                      frame_ptr--;
                    }
                  }
                else
                  if (((int)(int)(*(b_1070 + 1) - 80) == 0))
                    {
                      /* OCic.cbl:2732: PERFORM */
                      {
                        /* PERFORM 350-PROCEDURE-DIVISION */
                        frame_ptr++;
                        frame_ptr->perform_through = 94;
                        frame_ptr->return_address = &&l_181;
                        goto l_94;
                        l_181:
                        frame_ptr--;
                      }
                    }
          }
          /* OCic.cbl:2734: IF */
          {
            if ((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)))
              {
                /* OCic.cbl:2735: MOVE */
                {
                  memcpy (b_1070 + 115, b_1070 + 70, 32);
                }
              }
          }
          /* OCic.cbl:2737: IF */
          {
            if ((((int)(int)(*(b_433 + 5) - 89) == 0) && ((int)(int)(*(b_1070 + 1) - 73) != 0)))
              {
                /* OCic.cbl:2739: MOVE */
                {
                  memset (b_1070 + 115, 32, 32);
                  memset (b_1070 + 102, 32, 12);
                }
              }
          }
        }
      }

    /* EXIT PERFORM 80 */

    l_80:;
  }
  /* OCic.cbl:2744: CLOSE */
  {
    cob_exception_code = 0;
    {
      cob_close (h_EXPAND_CODE, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_182;
        goto l_1;
        l_182:
        frame_ptr--;
      }
  }
  /* OCic.cbl:2745: EXIT */
  {
    goto l_81;
  }

  /* 310-Get-Token */

  l_82:;
  /* OCic.cbl:2750: MOVE */
  {
    *(b_433 + 3) = *(b_433 + 5);
  }
  /* OCic.cbl:2751: MOVE */
  {
    *(b_433 + 5) = 78;
  }
  /* OCic.cbl:2752: PERFORM */
  {
    while (1)
      {
        if (((int)(int)(*(b_389 + ((*(int *)(b_1069)) - 1)) - ' ') != 0))
          break;
        {
          /* OCic.cbl:2753: IF */
          {
            if (((int)cob_cmp_s32_binary (b_1069, 255) >  0))
              {
                /* OCic.cbl:2754: READ */
                cob_exception_code = 0;
                {
                  cob_read (h_EXPAND_CODE, 0, NULL, 1);
                }
                if (unlikely(cob_exception_code != 0))
                  {
                    if (cob_exception_code == 0x0501)
                      {
                        {
                          /* OCic.cbl:2755: IF */
                          {
                            if (((int)cob_cmp (&f_457, &cob_space) != 0))
                              {
                                /* OCic.cbl:2756: MOVE */
                                {
                                  cob_move (&f_457, &f_392);
                                }
                                /* OCic.cbl:2757: MOVE */
                                {
                                  memset (b_457, 32, 100);
                                }
                                /* OCic.cbl:2758: RELEASE */
                                cob_exception_code = 0;
                                {
                                  cob_file_release (h_SORT_FILE);
                                }
                                if (unlikely(cob_exception_code != 0))
                                  {
                                    /* PERFORM Default Error Handler */
                                    frame_ptr++;
                                    frame_ptr->perform_through = 1;
                                    frame_ptr->return_address = &&l_183;
                                    goto l_1;
                                    l_183:
                                    frame_ptr--;
                                  }
                              }
                          }
                          /* OCic.cbl:2760: SET */
                          {
                            *(b_1070 + 147) = 255;
                          }
                          /* OCic.cbl:2761: MOVE */
                          {
                            memset (b_1070 + 2, 48, 6);
                          }
                          /* OCic.cbl:2762: EXIT */
                          {
                            goto l_83;
                          }
                        }
                      }
                    else
                      {
                        /* PERFORM Default Error Handler */
                        frame_ptr++;
                        frame_ptr->perform_through = 1;
                        frame_ptr->return_address = &&l_184;
                        goto l_1;
                        l_184:
                        frame_ptr--;
                      }
                  }
                /* OCic.cbl:2764: IF */
                {
                  if (((int)(int)(*(b_389) - 35) == 0))
                    {
                      /* OCic.cbl:2765: PERFORM */
                      {
                        /* PERFORM 311-Control-Record */
                        frame_ptr++;
                        frame_ptr->perform_through = 84;
                        frame_ptr->return_address = &&l_185;
                        goto l_84;
                        l_185:
                        frame_ptr--;
                      }
                    }
                  else
                    {
                      /* OCic.cbl:2767: PERFORM */
                      {
                        /* PERFORM 312-Expand-Code-Record */
                        frame_ptr++;
                        frame_ptr->perform_through = 85;
                        frame_ptr->return_address = &&l_186;
                        goto l_85;
                        l_186:
                        frame_ptr--;
                      }
                    }
                }
              }
            else
              {
                /* OCic.cbl:2770: ADD */
                {
                  (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
                }
              }
          }
        }
      }
  }
  /* OCic.cbl:2774: MOVE */
  {
    *(b_1070) = *(b_389 + ((*(int *)(b_1069)) - 1));
  }
  /* OCic.cbl:2775: MOVE */
  {
    *(b_1070 + 114) = *(b_389 + (((*(int *)(b_1069)) + 1) - 1));
  }
  /* OCic.cbl:2776: IF */
  {
    if (((int)(int)(*(b_1070) - 46) == 0))
      {
        /* OCic.cbl:2777: ADD */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
        }
        /* OCic.cbl:2778: MOVE */
        {
          cob_move (&f_1071, &f_1091);
        }
        /* OCic.cbl:2779: MOVE */
        {
          *(b_1070 + 147) = 32;
        }
        /* OCic.cbl:2780: MOVE */
        {
          *(b_433 + 5) = 89;
        }
        /* OCic.cbl:2781: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2783: IF */
  {
    if (((((((((((((((int)(int)(*(b_1070) - 61) == 0) || ((int)(int)(*(b_1070) - 40) == 0)) || ((int)(int)(*(b_1070) - 41) == 0)) || ((int)(int)(*(b_1070) - 42) == 0)) || ((int)(int)(*(b_1070) - 47) == 0)) || ((int)(int)(*(b_1070) - 38) == 0)) || ((int)(int)(*(b_1070) - 59) == 0)) || ((int)(int)(*(b_1070) - 44) == 0)) || ((int)(int)(*(b_1070) - 60) == 0)) || ((int)(int)(*(b_1070) - 62) == 0)) || ((int)(int)(*(b_1070) - 58) == 0)) && ((int)(int)(*(b_1070) - 61) == 0)) && ((int)(int)(*(b_1070 + 1) - 80) == 0)))
      {
        /* OCic.cbl:2786: ADD */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
        }
        /* OCic.cbl:2787: MOVE */
        {
          cob_move (&c_182, &f_1091);
        }
        /* OCic.cbl:2788: MOVE */
        {
          *(b_1070 + 147) = 75;
        }
        /* OCic.cbl:2789: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2791: IF */
  {
    if (((((((((((((((int)(int)(*(b_1070) - 61) == 0) || ((int)(int)(*(b_1070) - 40) == 0)) || ((int)(int)(*(b_1070) - 41) == 0)) || ((int)(int)(*(b_1070) - 42) == 0)) || ((int)(int)(*(b_1070) - 47) == 0)) || ((int)(int)(*(b_1070) - 38) == 0)) || ((int)(int)(*(b_1070) - 59) == 0)) || ((int)(int)(*(b_1070) - 44) == 0)) || ((int)(int)(*(b_1070) - 60) == 0)) || ((int)(int)(*(b_1070) - 62) == 0)) || ((int)(int)(*(b_1070) - 58) == 0)) && ((int)(int)(*(b_1070) - 40) == 0)) && ((int)(int)(*(b_1070 + 1) - 80) == 0)))
      {
        /* OCic.cbl:2794: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
      }
  }
  /* OCic.cbl:2796: IF */
  {
    if (((((((((((((int)(int)(*(b_1070) - 61) == 0) || ((int)(int)(*(b_1070) - 40) == 0)) || ((int)(int)(*(b_1070) - 41) == 0)) || ((int)(int)(*(b_1070) - 42) == 0)) || ((int)(int)(*(b_1070) - 47) == 0)) || ((int)(int)(*(b_1070) - 38) == 0)) || ((int)(int)(*(b_1070) - 59) == 0)) || ((int)(int)(*(b_1070) - 44) == 0)) || ((int)(int)(*(b_1070) - 60) == 0)) || ((int)(int)(*(b_1070) - 62) == 0)) || ((int)(int)(*(b_1070) - 58) == 0)))
      {
        /* OCic.cbl:2797: ADD */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
        }
        /* OCic.cbl:2798: MOVE */
        {
          cob_move (&f_1071, &f_1091);
        }
        /* OCic.cbl:2799: MOVE */
        {
          *(b_1070 + 147) = 32;
        }
        /* OCic.cbl:2800: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2802: IF */
  {
    if ((((int)(int)(*(b_1070) - 34) == 0) || ((int)(int)(*(b_1070) - 39) == 0)))
      {
        /* OCic.cbl:2803: ADD */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
        }
        /* OCic.cbl:2804: UNSTRING */
        {
          cob_unstring_init (&f_383, &f_1069, 1);
          cob_unstring_delimited (&f_1071, 0);
          cob_unstring_into (&f_1091, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:2809: IF */
        {
          if (((int)(int)(*(b_389 + ((*(int *)(b_1069)) - 1)) - 46) == 0))
            {
              /* OCic.cbl:2810: MOVE */
              {
                *(b_433 + 5) = 89;
              }
              /* OCic.cbl:2811: ADD */
              {
                (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
              }
            }
        }
        /* OCic.cbl:2813: SET */
        {
          *(b_1070 + 147) = 76;
        }
        /* OCic.cbl:2814: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2816: IF */
  {
    if (((((int)(int)(*(b_1070) - 120) == 0) || ((int)(int)(*(b_1070) - 88) == 0)) && (((int)(int)(*(b_1070 + 114) - 34) == 0) || ((int)(int)(*(b_1070 + 114) - 39) == 0))))
      {
        /* OCic.cbl:2817: ADD */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 2);
        }
        /* OCic.cbl:2818: UNSTRING */
        {
          cob_unstring_init (&f_383, &f_1069, 1);
          cob_unstring_delimited (&f_1094, 0);
          cob_unstring_into (&f_1091, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:2823: IF */
        {
          if (((int)(int)(*(b_389 + ((*(int *)(b_1069)) - 1)) - 46) == 0))
            {
              /* OCic.cbl:2824: MOVE */
              {
                *(b_433 + 5) = 89;
              }
              /* OCic.cbl:2825: ADD */
              {
                (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
              }
            }
        }
        /* OCic.cbl:2827: SET */
        {
          *(b_1070 + 147) = 78;
        }
        /* OCic.cbl:2828: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2830: IF */
  {
    if (((((int)(int)(*(b_1070) - 122) == 0) || ((int)(int)(*(b_1070) - 90) == 0)) && (((int)(int)(*(b_1070 + 114) - 34) == 0) || ((int)(int)(*(b_1070 + 114) - 39) == 0))))
      {
        /* OCic.cbl:2831: ADD */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 2);
        }
        /* OCic.cbl:2832: UNSTRING */
        {
          cob_unstring_init (&f_383, &f_1069, 1);
          cob_unstring_delimited (&f_1094, 0);
          cob_unstring_into (&f_1091, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:2837: IF */
        {
          if (((int)(int)(*(b_389 + ((*(int *)(b_1069)) - 1)) - 46) == 0))
            {
              /* OCic.cbl:2838: MOVE */
              {
                *(b_433 + 5) = 89;
              }
              /* OCic.cbl:2839: ADD */
              {
                (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
              }
            }
        }
        /* OCic.cbl:2841: SET */
        {
          *(b_1070 + 147) = 76;
        }
        /* OCic.cbl:2842: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2844: IF */
  {
    if (((int)(int)(*(b_433 + 4) - 89) == 0))
      {
        /* OCic.cbl:2845: UNSTRING */
        {
          cob_unstring_init (&f_383, &f_1069, 2);
          cob_unstring_delimited (&c_183, 0);
          cob_unstring_delimited (&c_138, 0);
          cob_unstring_into (&f_1091, &f_411, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:2851: IF */
        {
          if (((int)memcmp (b_411, (unsigned char *)". ", 2) == 0))
            {
              /* OCic.cbl:2852: MOVE */
              {
                *(b_433 + 5) = 89;
              }
              /* OCic.cbl:2853: ADD */
              {
                (*(int *)(b_1069)) = ((*(int *)(b_1069)) + 1);
              }
            }
        }
        /* OCic.cbl:2855: IF */
        {
          if (((int)cob_cmp (cob_intr_upper_case (0, 0, &f_1091), &c_184) == 0))
            {
              /* OCic.cbl:2856: MOVE */
              {
                *(b_1070 + 147) = 32;
              }
              /* OCic.cbl:2857: EXIT */
              {
                goto l_83;
              }
            }
          else
            {
              /* OCic.cbl:2859: MOVE */
              {
                *(b_433 + 4) = 78;
              }
              /* OCic.cbl:2860: MOVE */
              {
                *(b_1070 + 147) = 32;
              }
              /* OCic.cbl:2861: EXIT */
              {
                goto l_83;
              }
            }
        }
      }
  }
  /* OCic.cbl:2864: UNSTRING */
  {
    cob_unstring_init (&f_383, &f_1069, 13);
    cob_unstring_delimited (&c_183, 0);
    cob_unstring_delimited (&c_138, 0);
    cob_unstring_delimited (&c_93, 0);
    cob_unstring_delimited (&c_185, 0);
    cob_unstring_delimited (&c_186, 0);
    cob_unstring_delimited (&c_139, 0);
    cob_unstring_delimited (&c_133, 0);
    cob_unstring_delimited (&c_187, 0);
    cob_unstring_delimited (&c_173, 0);
    cob_unstring_delimited (&c_188, 0);
    cob_unstring_delimited (&c_189, 0);
    cob_unstring_delimited (&c_137, 0);
    cob_unstring_delimited (&c_132, 0);
    cob_unstring_into (&f_1091, &f_411, 0);
    cob_unstring_finish ();
  }
  /* OCic.cbl:2872: IF */
  {
    if (((int)memcmp (b_411, (unsigned char *)". ", 2) == 0))
      {
        /* OCic.cbl:2873: MOVE */
        {
          *(b_433 + 5) = 89;
        }
      }
  }
  /* OCic.cbl:2875: IF */
  {
    if ((((int)memcmp (b_411, (unsigned char *)". ", 2) != 0) && ((int)cob_cmp (&f_411, &c_138) != 0)))
      {
        /* OCic.cbl:2876: SUBTRACT */
        {
          (*(int *)(b_1069)) = ((*(int *)(b_1069)) - 1);
        }
      }
  }
  /* OCic.cbl:2879: MOVE */
  {
    cob_move (cob_intr_upper_case (0, 0, &f_1091), &f_1067);
  }
  /* OCic.cbl:2880: IF */
  {
    if ((((int)cob_cmp (&f_1067, &c_190) == 0) || ((int)cob_cmp (&f_1067, &c_182) == 0)))
      {
        /* OCic.cbl:2881: MOVE */
        {
          cob_move (&c_182, &f_1091);
        }
        /* OCic.cbl:2882: MOVE */
        {
          *(b_1070 + 147) = 75;
        }
        /* OCic.cbl:2883: EXIT */
        {
          goto l_83;
        }
      }
  }
  /* OCic.cbl:2885: SEARCH */
  {
    {
      int ret;
      int head = 1 - 1;
      int tail = 591 + 1;
      while (1)
        {
          if (head >= tail - 1)
            {
              break;
            }
          (*(int *) (b_1063)) = (head + tail) / 2;
          if (((int)(ret = memcmp (b_469 + 1 + 33 * ((*(int *) (b_1063)) - 1), b_1067, 32)) == 0))
            {
              /* OCic.cbl:2887: MOVE */
              {
                *(b_1070 + 147) = *(b_469 + 33 * ((*(int *) (b_1063)) - 1));
              }
              /* OCic.cbl:2888: IF */
              {
                if (((int)(int)(*(b_1070 + 147) - 86) == 0))
                  {
                    /* OCic.cbl:2889: MOVE */
                    {
                      *(b_433 + 6) = 89;
                    }
                  }
              }
              /* OCic.cbl:2891: EXIT */
              {
                goto l_83;
              }
            }
          else
            {
              if (ret < 0)
                head = (*(int *) (b_1063));
              else
                tail = (*(int *) (b_1063));
              continue;
            }
          break;
        }
    }
  }
  /* OCic.cbl:2894: SET */
  {
    *(b_1070 + 147) = 73;
  }
  /* OCic.cbl:2895: PERFORM */
  {
    /* PERFORM 313-Check-For-Numeric-Token */
    frame_ptr++;
    frame_ptr->perform_through = 86;
    frame_ptr->return_address = &&l_187;
    goto l_86;
    l_187:
    frame_ptr--;
  }
  /* OCic.cbl:2896: IF */
  {
    if (((int)(int)(*(b_1070 + 147) - 78) == 0))
      {
        /* OCic.cbl:2897: IF */
        {
          if ((((int)(int)(*(b_433 + 3) - 89) == 0) && ((int)(int)(*(b_1070 + 1) - 68) == 0)))
            {
              /* OCic.cbl:2899: MOVE */
              {
                cob_move (&c_191, &f_1091);
              }
              /* OCic.cbl:2900: MOVE */
              {
                *(b_1070 + 147) = 75;
              }
              /* OCic.cbl:2901: EXIT */
              {
                goto l_83;
              }
            }
          else
            {
              /* OCic.cbl:2903: EXIT */
              {
                goto l_83;
              }
            }
        }
      }
  }
  /* OCic.cbl:2906: EXIT */
  {
    goto l_83;
  }

  /* EXIT PARAGRAPH 83 */

  l_83:;

  if (frame_ptr->perform_through == 82)
    goto *frame_ptr->return_address;

  /* 311-Control-Record */

  l_84:;
  /* OCic.cbl:2910: UNSTRING */
  {
    cob_unstring_init (&f_385, 0, 1);
    cob_unstring_delimited (&c_91, 0);
    cob_unstring_into (&f_464, 0, 0);
    cob_unstring_into (&f_466, 0, 0);
    cob_unstring_into (&f_429, 0, 0);
    cob_unstring_finish ();
  }
  /* OCic.cbl:2914: INSPECT */
  {
    cob_inspect_init (&f_464, 1);
    cob_inspect_start ();
    cob_inspect_all (&cob_space, &c_91);
    cob_inspect_finish ();
  }
  /* OCic.cbl:2915: COMPUTE */
  {
    {
      {
        cob_decimal_set_field (&d0, cob_intr_numval (&f_464));
        cob_decimal_set_int (&d1, 1);
        cob_decimal_sub (&d0, &d1);
        cob_decimal_get_field (&d0, &f_458, 0);
      }
    }
  }
  /* OCic.cbl:2916: IF */
  {
    if (((int)cob_cmp (cob_intr_trim (0, 0, &f_466, 2), cob_intr_trim (0, 0, &f_467, 2)) == 0))
      {
        /* OCic.cbl:2917: MOVE */
        {
          cob_move (&f_458, &f_1081);
        }
        /* OCic.cbl:2918: SET */
        {
          *(b_433 + 2) = 77;
        }
        /* OCic.cbl:2919: IF */
        {
          if (((int)cob_cmp (&f_1066, &cob_space) != 0))
            {
              /* OCic.cbl:2920: MOVE */
              {
                memcpy (b_1070 + 23, b_1066, 15);
              }
            }
        }
      }
    else
      {
        /* OCic.cbl:2923: SET */
        {
          *(b_433 + 2) = 67;
        }
        /* OCic.cbl:2924: IF */
        {
          if (((int)cob_cmp (&f_1066, &cob_space) == 0))
            {
              /* OCic.cbl:2925: MOVE */
              {
                memcpy (b_1066, b_1070 + 23, 15);
              }
            }
        }
        /* OCic.cbl:2927: MOVE */
        {
          cob_move (cob_intr_length (cob_intr_trim (0, 0, &f_466, 2)), &f_458);
        }
        /* OCic.cbl:2928: MOVE */
        {
          (*(int *)(b_459)) = 0;
        }
        /* OCic.cbl:2929: PERFORM */
        {
          while (1)
            {
              if ((((int)(int)(*(b_466 + ((*(int *)(b_458)) - 1)) - 47) == 0) || ((int)cob_cmp_s32_binary (b_458, 0) == 0)))
                break;
              {
                /* OCic.cbl:2931: SUBTRACT */
                {
                  (*(int *)(b_458)) = ((*(int *)(b_458)) - 1);
                }
                /* OCic.cbl:2932: ADD */
                {
                  (*(int *)(b_459)) = ((*(int *)(b_459)) + 1);
                }
              }
            }
        }
        /* OCic.cbl:2934: UNSTRING */
        {
          cob_unstring_init ((f0.size = (*(int *)(b_459)), f0.data = b_466 + (((*(int *)(b_458)) + 1) - 1), f0.attr = &a_2, &f0), 0, 1);
          cob_unstring_delimited (&c_140, 0);
          cob_unstring_into (&f_432, 0, 0);
          cob_unstring_into (&f_429, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:2937: MOVE */
        {
          *(b_1070 + 23) = 91;
        }
        /* OCic.cbl:2938: MOVE */
        {
          memcpy (b_1070 + 24, b_432, 13);
        }
        /* OCic.cbl:2939: IF */
        {
          if (((int)cob_cmp (&f_1089, &cob_space) != 0))
            {
              /* OCic.cbl:2940: MOVE */
              {
                memset (b_1070 + 34, 46, 3);
              }
            }
        }
        /* OCic.cbl:2942: MOVE */
        {
          *(b_1070 + 37) = 93;
        }
      }
  }
  /* OCic.cbl:2944: MOVE */
  {
    memset (b_389, 32, 257);
  }
  /* OCic.cbl:2945: MOVE */
  {
    (*(int *)(b_1069)) = 256;
  }

  if (frame_ptr->perform_through == 84)
    goto *frame_ptr->return_address;

  /* 312-Expand-Code-Record */

  l_85:;
  /* OCic.cbl:2949: MOVE */
  {
    (*(int *)(b_1069)) = 1;
  }
  /* OCic.cbl:2950: IF */
  {
    if (((int)(int)(*(b_433 + 2) - 77) == 0))
      {
        /* OCic.cbl:2951: ADD */
        {
          cob_add (&f_1081, &c_70, 2);
        }
      }
  }

  if (frame_ptr->perform_through == 85)
    goto *frame_ptr->return_address;

  /* 313-Check-For-Numeric-Token */

  l_86:;
  /* OCic.cbl:2956: MOVE */
  {
    memcpy (b_465, b_1070 + 38, 32);
  }
  /* OCic.cbl:2957: INSPECT */
  {
    cob_inspect_init (&f_465, 1);
    cob_inspect_start ();
    cob_inspect_trailing (&c_192, &cob_space);
    cob_inspect_finish ();
  }
  /* OCic.cbl:2959: IF */
  {
    if (cob_is_numeric (&f_465))
      {
        /* OCic.cbl:2960: SET */
        {
          *(b_1070 + 147) = 78;
        }
        /* OCic.cbl:2961: EXIT */
        {
          goto l_87;
        }
      }
  }
  /* OCic.cbl:2963: IF */
  {
    if ((((int)(int)(*(b_465 + 0) - 43) == 0) || ((int)(int)(*(b_465 + 0) - 45) == 0)))
      {
        /* OCic.cbl:2964: MOVE */
        {
          cob_move (&c_192, (f0.size = 1, f0.data = b_465 + 0, f0.attr = &a_2, &f0));
        }
      }
  }
  /* OCic.cbl:2966: MOVE */
  {
    (*(int *)(b_1105)) = 0;
  }
  /* OCic.cbl:2967: INSPECT */
  {
    cob_inspect_init (&f_465, 0);
    cob_inspect_start ();
    cob_inspect_all (&f_1105, &c_140);
    cob_inspect_finish ();
  }
  /* OCic.cbl:2969: IF */
  {
    if (((int)cob_cmp_s32_binary (b_1105, 1) == 0))
      {
        /* OCic.cbl:2970: INSPECT */
        {
          cob_inspect_init (&f_465, 1);
          cob_inspect_start ();
          cob_inspect_all (&c_192, &c_140);
          cob_inspect_finish ();
        }
      }
  }
  /* OCic.cbl:2972: IF */
  {
    if (cob_is_numeric (&f_465))
      {
        /* OCic.cbl:2973: SET */
        {
          *(b_1070 + 147) = 78;
        }
        /* OCic.cbl:2974: EXIT */
        {
          goto l_87;
        }
      }
  }

  /* EXIT PARAGRAPH 87 */

  l_87:;

  if (frame_ptr->perform_through == 86)
    goto *frame_ptr->return_address;

  /* 320-IDENTIFICATION-DIVISION */

  l_88:;
  /* OCic.cbl:2979: MOVE */
  {
    *(b_433 + 6) = 78;
  }
  /* OCic.cbl:2980: IF */
  {
    if (((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)) && ((int)cob_cmp (&f_1091, &c_193) == 0)))
      {
        /* OCic.cbl:2981: MOVE */
        {
          *(b_1070 + 1) = *(b_1070 + 115);
        }
        /* OCic.cbl:2982: EXIT */
        {
          goto l_89;
        }
      }
  }
  /* OCic.cbl:2984: IF */
  {
    if (((int)cob_cmp (&f_1096, &c_194) == 0))
      {
        /* OCic.cbl:2985: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
        /* OCic.cbl:2986: MOVE */
        {
          memcpy (b_1070 + 8, b_1070 + 38, 15);
        }
        /* OCic.cbl:2987: IF */
        {
          if (((int)cob_cmp (&f_1084, &cob_space) != 0))
            {
              /* OCic.cbl:2988: MOVE */
              {
                memset (b_1070 + 20, 46, 3);
              }
            }
        }
        /* OCic.cbl:2990: EXIT */
        {
          goto l_89;
        }
      }
  }

  /* EXIT PARAGRAPH 89 */

  l_89:;

  if (frame_ptr->perform_through == 88)
    goto *frame_ptr->return_address;

  /* 330-ENVIRONMENT-DIVISION */

  l_90:;
  /* OCic.cbl:2995: IF */
  {
    if (((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)) && ((int)cob_cmp (&f_1091, &c_193) == 0)))
      {
        /* OCic.cbl:2996: MOVE */
        {
          *(b_1070 + 1) = *(b_1070 + 115);
        }
        /* OCic.cbl:2997: EXIT */
        {
          goto l_91;
        }
      }
  }
  /* OCic.cbl:2999: IF */
  {
    if (((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)) && ((int)cob_cmp (&f_1091, &c_195) == 0)))
      {
        /* OCic.cbl:3000: MOVE */
        {
          memcpy (b_1070 + 23, b_1070 + 115, 15);
        }
        /* OCic.cbl:3001: EXIT */
        {
          goto l_91;
        }
      }
  }
  /* OCic.cbl:3003: IF */
  {
    if (((int)(int)(*(b_1070 + 147) - 73) == 0))
      {
        /* OCic.cbl:3004: PERFORM */
        {
          /* PERFORM 361-Release-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 114;
          frame_ptr->return_address = &&l_188;
          goto l_114;
          l_188:
          frame_ptr--;
        }
      }
  }

  /* EXIT PARAGRAPH 91 */

  l_91:;

  if (frame_ptr->perform_through == 90)
    goto *frame_ptr->return_address;

  /* 340-DATA-DIVISION */

  l_92:;
  /* OCic.cbl:3009: IF */
  {
    if (((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)) && ((int)cob_cmp (&f_1091, &c_193) == 0)))
      {
        /* OCic.cbl:3010: MOVE */
        {
          *(b_1070 + 1) = *(b_1070 + 115);
        }
        /* OCic.cbl:3011: EXIT */
        {
          goto l_93;
        }
      }
  }
  /* OCic.cbl:3013: IF */
  {
    if (((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)) && ((int)cob_cmp (&f_1091, &c_195) == 0)))
      {
        /* OCic.cbl:3014: MOVE */
        {
          memcpy (b_1070 + 23, b_1070 + 115, 15);
        }
        /* OCic.cbl:3015: EXIT */
        {
          goto l_93;
        }
      }
  }
  /* OCic.cbl:3017: IF */
  {
    if (((((int)cob_cmp (&f_1091, &c_196) == 0) || ((int)cob_cmp (&f_1091, &c_197) == 0)) && (((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0))))
      {
        /* OCic.cbl:3019: MOVE */
        {
          *(b_433 + 4) = 89;
        }
        /* OCic.cbl:3020: EXIT */
        {
          goto l_93;
        }
      }
  }
  /* OCic.cbl:3022: IF */
  {
    if ((((int)(int)(*(b_1070 + 147) - 32) == 0) && ((int)cob_cmp (&f_1096, &c_191) == 0)))
      {
        /* OCic.cbl:3024: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
        /* OCic.cbl:3025: EXIT */
        {
          goto l_93;
        }
      }
  }
  /* OCic.cbl:3027: IF */
  {
    if (((int)(int)(*(b_1070 + 147) - 73) == 0))
      {
        /* OCic.cbl:3028: EVALUATE */
        {
          if (((int)cob_cmp (&f_1096, &c_198) == 0))
            {
              /* OCic.cbl:3030: PERFORM */
              {
                /* PERFORM 360-Release-Def */
                frame_ptr++;
                frame_ptr->perform_through = 113;
                frame_ptr->return_address = &&l_189;
                goto l_113;
                l_189:
                frame_ptr--;
              }
              /* OCic.cbl:3031: MOVE */
              {
                memset (b_1070 + 115, 32, 32);
              }
            }
          else
            if (((int)cob_cmp (&f_1096, &c_199) == 0))
              {
                /* OCic.cbl:3033: PERFORM */
                {
                  /* PERFORM 360-Release-Def */
                  frame_ptr++;
                  frame_ptr->perform_through = 113;
                  frame_ptr->return_address = &&l_190;
                  goto l_113;
                  l_190:
                  frame_ptr--;
                }
                /* OCic.cbl:3034: MOVE */
                {
                  memset (b_1070 + 115, 32, 32);
                }
              }
            else
              if (((int)cob_cmp (&f_1096, &c_191) == 0))
                {
                  /* OCic.cbl:3036: PERFORM */
                  {
                    /* PERFORM 360-Release-Def */
                    frame_ptr++;
                    frame_ptr->perform_through = 113;
                    frame_ptr->return_address = &&l_191;
                    goto l_113;
                    l_191:
                    frame_ptr--;
                  }
                  /* OCic.cbl:3037: MOVE */
                  {
                    memset (b_1070 + 115, 32, 32);
                  }
                }
              else
                if (((int)cob_cmp (&f_1096, &c_200) == 0))
                  {
                    /* OCic.cbl:3039: PERFORM */
                    {
                      /* PERFORM 360-Release-Def */
                      frame_ptr++;
                      frame_ptr->perform_through = 113;
                      frame_ptr->return_address = &&l_192;
                      goto l_113;
                      l_192:
                      frame_ptr--;
                    }
                    /* OCic.cbl:3040: MOVE */
                    {
                      memset (b_1070 + 115, 32, 32);
                    }
                  }
                else
                  if (((int)cob_cmp (&f_1096, &c_201) == 0))
                    {
                      /* OCic.cbl:3042: PERFORM */
                      {
                        /* PERFORM 362-Release-Upd */
                        frame_ptr++;
                        frame_ptr->perform_through = 115;
                        frame_ptr->return_address = &&l_193;
                        goto l_115;
                        l_193:
                        frame_ptr--;
                      }
                      /* OCic.cbl:3043: MOVE */
                      {
                        memset (b_1070 + 115, 32, 32);
                      }
                    }
                  else
                    if (((int)cob_cmp (&f_1096, &c_202) == 0))
                      {
                        /* OCic.cbl:3045: PERFORM */
                        {
                          /* PERFORM 362-Release-Upd */
                          frame_ptr++;
                          frame_ptr->perform_through = 115;
                          frame_ptr->return_address = &&l_194;
                          goto l_115;
                          l_194:
                          frame_ptr--;
                        }
                        /* OCic.cbl:3046: MOVE */
                        {
                          memset (b_1070 + 115, 32, 32);
                        }
                      }
                    else
                      {
                        /* OCic.cbl:3048: PERFORM */
                        {
                          /* PERFORM 361-Release-Ref */
                          frame_ptr++;
                          frame_ptr->perform_through = 114;
                          frame_ptr->return_address = &&l_195;
                          goto l_114;
                          l_195:
                          frame_ptr--;
                        }
                      }
        }
        /* OCic.cbl:3050: EXIT */
        {
          goto l_93;
        }
      }
  }

  /* EXIT PARAGRAPH 93 */

  l_93:;

  if (frame_ptr->perform_through == 92)
    goto *frame_ptr->return_address;

  /* 350-PROCEDURE-DIVISION */

  l_94:;
  /* OCic.cbl:3055: IF */
  {
    if (((int)cob_cmp (&f_1085, &c_203) != 0))
      {
        /* OCic.cbl:3056: MOVE */
        {
          memcpy (b_1070 + 23, "PROCEDURE      ", 15);
        }
      }
  }
  /* OCic.cbl:3058: IF */
  {
    if ((((int)cob_cmp (&f_1092, &c_204) == 0) && ((int)cob_cmp (&f_1096, &c_205) == 0)))
      {
        /* OCic.cbl:3060: MOVE */
        {
          *(b_1070 + 1) = 63;
        }
        /* OCic.cbl:3061: EXIT */
        {
          goto l_95;
        }
      }
  }
  /* OCic.cbl:3063: IF */
  {
    if (((((int)(int)(*(b_1070 + 147) - 75) == 0) || ((int)(int)(*(b_1070 + 147) - 86) == 0)) && ((int)cob_cmp (&f_1091, &c_193) == 0)))
      {
        /* OCic.cbl:3064: MOVE */
        {
          *(b_1070 + 1) = *(b_1070 + 115);
        }
        /* OCic.cbl:3065: EXIT */
        {
          goto l_95;
        }
      }
  }
  /* OCic.cbl:3067: IF */
  {
    if ((((int)cob_cmp (&f_1093, &cob_space) == 0) && ((int)(int)(*(b_433 + 6) - 89) == 0)))
      {
        /* OCic.cbl:3069: IF */
        {
          if (((int)(int)(*(b_1070 + 147) - 73) == 0))
            {
              /* OCic.cbl:3070: PERFORM */
              {
                /* PERFORM 360-Release-Def */
                frame_ptr++;
                frame_ptr->perform_through = 113;
                frame_ptr->return_address = &&l_196;
                goto l_113;
                l_196:
                frame_ptr--;
              }
              /* OCic.cbl:3071: MOVE */
              {
                memset (b_1070 + 115, 32, 32);
              }
            }
        }
        /* OCic.cbl:3073: EXIT */
        {
          goto l_95;
        }
      }
  }
  /* OCic.cbl:3075: IF */
  {
    if (!((int)(int)(*(b_1070 + 147) - 73) == 0))
      {
        /* OCic.cbl:3076: EXIT */
        {
          goto l_95;
        }
      }
  }
  /* OCic.cbl:3078: EVALUATE */
  {
    if (((int)cob_cmp (&f_1093, &c_206) == 0))
      {
        /* OCic.cbl:3080: PERFORM */
        {
          /* PERFORM 351-ACCEPT */
          frame_ptr++;
          frame_ptr->perform_through = 96;
          frame_ptr->return_address = &&l_197;
          goto l_96;
          l_197:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1093, &c_207) == 0))
        {
          /* OCic.cbl:3082: PERFORM */
          {
            /* PERFORM 351-ADD */
            frame_ptr++;
            frame_ptr->perform_through = 97;
            frame_ptr->return_address = &&l_198;
            goto l_97;
            l_198:
            frame_ptr--;
          }
        }
      else
        if (((int)cob_cmp (&f_1093, &c_208) == 0))
          {
            /* OCic.cbl:3084: PERFORM */
            {
              /* PERFORM 351-ALLOCATE */
              frame_ptr++;
              frame_ptr->perform_through = 98;
              frame_ptr->return_address = &&l_199;
              goto l_98;
              l_199:
              frame_ptr--;
            }
          }
        else
          if (((int)cob_cmp (&f_1093, &c_209) == 0))
            {
              /* OCic.cbl:3086: PERFORM */
              {
                /* PERFORM 351-CALL */
                frame_ptr++;
                frame_ptr->perform_through = 99;
                frame_ptr->return_address = &&l_200;
                goto l_99;
                l_200:
                frame_ptr--;
              }
            }
          else
            if (((int)cob_cmp (&f_1093, &c_210) == 0))
              {
                /* OCic.cbl:3088: PERFORM */
                {
                  /* PERFORM 351-COMPUTE */
                  frame_ptr++;
                  frame_ptr->perform_through = 100;
                  frame_ptr->return_address = &&l_201;
                  goto l_100;
                  l_201:
                  frame_ptr--;
                }
              }
            else
              if (((int)cob_cmp (&f_1093, &c_211) == 0))
                {
                  /* OCic.cbl:3090: PERFORM */
                  {
                    /* PERFORM 351-DIVIDE */
                    frame_ptr++;
                    frame_ptr->perform_through = 101;
                    frame_ptr->return_address = &&l_202;
                    goto l_101;
                    l_202:
                    frame_ptr--;
                  }
                }
              else
                if (((int)cob_cmp (&f_1093, &c_212) == 0))
                  {
                    /* OCic.cbl:3092: PERFORM */
                    {
                      /* PERFORM 351-FREE */
                      frame_ptr++;
                      frame_ptr->perform_through = 102;
                      frame_ptr->return_address = &&l_203;
                      goto l_102;
                      l_203:
                      frame_ptr--;
                    }
                  }
                else
                  if (((int)cob_cmp (&f_1093, &c_213) == 0))
                    {
                      /* OCic.cbl:3094: PERFORM */
                      {
                        /* PERFORM 351-INITIALIZE */
                        frame_ptr++;
                        frame_ptr->perform_through = 103;
                        frame_ptr->return_address = &&l_204;
                        goto l_103;
                        l_204:
                        frame_ptr--;
                      }
                    }
                  else
                    if (((int)cob_cmp (&f_1093, &c_214) == 0))
                      {
                        /* OCic.cbl:3096: PERFORM */
                        {
                          /* PERFORM 351-INSPECT */
                          frame_ptr++;
                          frame_ptr->perform_through = 104;
                          frame_ptr->return_address = &&l_205;
                          goto l_104;
                          l_205:
                          frame_ptr--;
                        }
                      }
                    else
                      if (((int)cob_cmp (&f_1093, &c_215) == 0))
                        {
                          /* OCic.cbl:3098: PERFORM */
                          {
                            /* PERFORM 351-MOVE */
                            frame_ptr++;
                            frame_ptr->perform_through = 105;
                            frame_ptr->return_address = &&l_206;
                            goto l_105;
                            l_206:
                            frame_ptr--;
                          }
                        }
                      else
                        if (((int)cob_cmp (&f_1093, &c_216) == 0))
                          {
                            /* OCic.cbl:3100: PERFORM */
                            {
                              /* PERFORM 351-MULTIPLY */
                              frame_ptr++;
                              frame_ptr->perform_through = 106;
                              frame_ptr->return_address = &&l_207;
                              goto l_106;
                              l_207:
                              frame_ptr--;
                            }
                          }
                        else
                          if (((int)cob_cmp (&f_1093, &c_217) == 0))
                            {
                              /* OCic.cbl:3102: PERFORM */
                              {
                                /* PERFORM 351-PERFORM */
                                frame_ptr++;
                                frame_ptr->perform_through = 107;
                                frame_ptr->return_address = &&l_208;
                                goto l_107;
                                l_208:
                                frame_ptr--;
                              }
                            }
                          else
                            if (((int)cob_cmp (&f_1093, &c_218) == 0))
                              {
                                /* OCic.cbl:3104: PERFORM */
                                {
                                  /* PERFORM 351-SET */
                                  frame_ptr++;
                                  frame_ptr->perform_through = 108;
                                  frame_ptr->return_address = &&l_209;
                                  goto l_108;
                                  l_209:
                                  frame_ptr--;
                                }
                              }
                            else
                              if (((int)cob_cmp (&f_1093, &c_219) == 0))
                                {
                                  /* OCic.cbl:3106: PERFORM */
                                  {
                                    /* PERFORM 351-STRING */
                                    frame_ptr++;
                                    frame_ptr->perform_through = 109;
                                    frame_ptr->return_address = &&l_210;
                                    goto l_109;
                                    l_210:
                                    frame_ptr--;
                                  }
                                }
                              else
                                if (((int)cob_cmp (&f_1093, &c_220) == 0))
                                  {
                                    /* OCic.cbl:3108: PERFORM */
                                    {
                                      /* PERFORM 351-SUBTRACT */
                                      frame_ptr++;
                                      frame_ptr->perform_through = 110;
                                      frame_ptr->return_address = &&l_211;
                                      goto l_110;
                                      l_211:
                                      frame_ptr--;
                                    }
                                  }
                                else
                                  if (((int)cob_cmp (&f_1093, &c_221) == 0))
                                    {
                                      /* OCic.cbl:3110: PERFORM */
                                      {
                                        /* PERFORM 351-TRANSFORM */
                                        frame_ptr++;
                                        frame_ptr->perform_through = 111;
                                        frame_ptr->return_address = &&l_212;
                                        goto l_111;
                                        l_212:
                                        frame_ptr--;
                                      }
                                    }
                                  else
                                    if (((int)cob_cmp (&f_1093, &c_222) == 0))
                                      {
                                        /* OCic.cbl:3112: PERFORM */
                                        {
                                          /* PERFORM 351-UNSTRING */
                                          frame_ptr++;
                                          frame_ptr->perform_through = 112;
                                          frame_ptr->return_address = &&l_213;
                                          goto l_112;
                                          l_213:
                                          frame_ptr--;
                                        }
                                      }
                                    else
                                      {
                                        /* OCic.cbl:3114: PERFORM */
                                        {
                                          /* PERFORM 361-Release-Ref */
                                          frame_ptr++;
                                          frame_ptr->perform_through = 114;
                                          frame_ptr->return_address = &&l_214;
                                          goto l_114;
                                          l_214:
                                          frame_ptr--;
                                        }
                                      }
  }

  /* EXIT PARAGRAPH 95 */

  l_95:;

  if (frame_ptr->perform_through == 94)
    goto *frame_ptr->return_address;

  /* 351-ACCEPT */

  l_96:;
  /* OCic.cbl:3119: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_206) == 0))
      {
        /* OCic.cbl:3121: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_215;
          goto l_115;
          l_215:
          frame_ptr--;
        }
        /* OCic.cbl:3122: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
      }
    else
      {
        /* OCic.cbl:3124: PERFORM */
        {
          /* PERFORM 361-Release-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 114;
          frame_ptr->return_address = &&l_216;
          goto l_114;
          l_216:
          frame_ptr--;
        }
      }
  }

  if (frame_ptr->perform_through == 96)
    goto *frame_ptr->return_address;

  /* 351-ADD */

  l_97:;
  /* OCic.cbl:3129: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_223) == 0))
      {
        /* OCic.cbl:3131: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_217;
          goto l_115;
          l_217:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_224) == 0))
        {
          /* OCic.cbl:3133: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_218;
            goto l_115;
            l_218:
            frame_ptr--;
          }
        }
      else
        {
          /* OCic.cbl:3135: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_219;
            goto l_114;
            l_219:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 97)
    goto *frame_ptr->return_address;

  /* 351-ALLOCATE */

  l_98:;
  /* OCic.cbl:3140: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_208) == 0))
      {
        /* OCic.cbl:3142: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_220;
          goto l_115;
          l_220:
          frame_ptr--;
        }
        /* OCic.cbl:3143: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_225) == 0))
        {
          /* OCic.cbl:3145: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_221;
            goto l_115;
            l_221:
            frame_ptr--;
          }
        }
      else
        {
          /* OCic.cbl:3147: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_222;
            goto l_114;
            l_222:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 98)
    goto *frame_ptr->return_address;

  /* 351-CALL */

  l_99:;
  /* OCic.cbl:3152: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_225) == 0))
      {
        /* OCic.cbl:3154: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_223;
          goto l_115;
          l_223:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_223) == 0))
        {
          /* OCic.cbl:3156: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_224;
            goto l_115;
            l_224:
            frame_ptr--;
          }
        }
      else
        {
          /* OCic.cbl:3158: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_225;
            goto l_114;
            l_225:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 99)
    goto *frame_ptr->return_address;

  /* 351-COMPUTE */

  l_100:;
  /* OCic.cbl:3163: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_210) == 0))
      {
        /* OCic.cbl:3165: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_226;
          goto l_115;
          l_226:
          frame_ptr--;
        }
      }
    else
      {
        /* OCic.cbl:3167: PERFORM */
        {
          /* PERFORM 361-Release-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 114;
          frame_ptr->return_address = &&l_227;
          goto l_114;
          l_227:
          frame_ptr--;
        }
      }
  }

  if (frame_ptr->perform_through == 100)
    goto *frame_ptr->return_address;

  /* 351-DIVIDE */

  l_101:;
  /* OCic.cbl:3172: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_202) == 0))
      {
        /* OCic.cbl:3174: PERFORM */
        {
          /* PERFORM 363-Set-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 116;
          frame_ptr->return_address = &&l_228;
          goto l_116;
          l_228:
          frame_ptr--;
        }
        /* OCic.cbl:3175: MOVE */
        {
          memcpy (b_457, b_401, 100);
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_223) == 0))
        {
          /* OCic.cbl:3177: IF */
          {
            if (((int)cob_cmp (&f_457, &cob_space) != 0))
              {
                /* OCic.cbl:3178: MOVE */
                {
                  cob_move (&f_457, &f_392);
                }
                /* OCic.cbl:3179: MOVE */
                {
                  memset (b_457, 32, 100);
                  *(b_401 + 106) = 32;
                }
                /* OCic.cbl:3181: RELEASE */
                cob_exception_code = 0;
                {
                  cob_file_release (h_SORT_FILE);
                }
                if (unlikely(cob_exception_code != 0))
                  {
                    /* PERFORM Default Error Handler */
                    frame_ptr++;
                    frame_ptr->perform_through = 1;
                    frame_ptr->return_address = &&l_229;
                    goto l_1;
                    l_229:
                    frame_ptr--;
                  }
              }
          }
          /* OCic.cbl:3183: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_230;
            goto l_115;
            l_230:
            frame_ptr--;
          }
        }
      else
        if (((int)cob_cmp (&f_1096, &c_226) == 0))
          {
            /* OCic.cbl:3185: PERFORM */
            {
              /* PERFORM 362-Release-Upd */
              frame_ptr++;
              frame_ptr->perform_through = 115;
              frame_ptr->return_address = &&l_231;
              goto l_115;
              l_231:
              frame_ptr--;
            }
          }
        else
          {
            /* OCic.cbl:3187: PERFORM */
            {
              /* PERFORM 361-Release-Ref */
              frame_ptr++;
              frame_ptr->perform_through = 114;
              frame_ptr->return_address = &&l_232;
              goto l_114;
              l_232:
              frame_ptr--;
            }
          }
  }

  if (frame_ptr->perform_through == 101)
    goto *frame_ptr->return_address;

  /* 351-FREE */

  l_102:;
  /* OCic.cbl:3192: PERFORM */
  {
    /* PERFORM 362-Release-Upd */
    frame_ptr++;
    frame_ptr->perform_through = 115;
    frame_ptr->return_address = &&l_233;
    goto l_115;
    l_233:
    frame_ptr--;
  }

  if (frame_ptr->perform_through == 102)
    goto *frame_ptr->return_address;

  /* 351-INITIALIZE */

  l_103:;
  /* OCic.cbl:3196: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_213) == 0))
      {
        /* OCic.cbl:3198: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_234;
          goto l_115;
          l_234:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_227) == 0))
        {
          /* OCic.cbl:3200: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_235;
            goto l_114;
            l_235:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 103)
    goto *frame_ptr->return_address;

  /* 351-INSPECT */

  l_104:;
  /* OCic.cbl:3205: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_214) == 0))
      {
        /* OCic.cbl:3207: PERFORM */
        {
          /* PERFORM 364-Set-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 117;
          frame_ptr->return_address = &&l_236;
          goto l_117;
          l_236:
          frame_ptr--;
        }
        /* OCic.cbl:3208: MOVE */
        {
          memset (b_457, 32, 100);
        }
        /* OCic.cbl:3209: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_228) == 0))
        {
          /* OCic.cbl:3211: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_237;
            goto l_115;
            l_237:
            frame_ptr--;
          }
          /* OCic.cbl:3212: MOVE */
          {
            memset (b_1070 + 115, 32, 32);
          }
        }
      else
        if (((int)cob_cmp (&f_1096, &c_227) == 0))
          {
            /* OCic.cbl:3214: IF */
            {
              if (((int)cob_cmp (&f_457, &cob_space) != 0))
                {
                  /* OCic.cbl:3215: MOVE */
                  {
                    cob_move (&f_457, &f_392);
                  }
                  /* OCic.cbl:3216: MOVE */
                  {
                    memset (b_457, 32, 100);
                  }
                  /* OCic.cbl:3217: MOVE */
                  {
                    *(b_401 + 106) = 42;
                  }
                  /* OCic.cbl:3218: RELEASE */
                  cob_exception_code = 0;
                  {
                    cob_file_release (h_SORT_FILE);
                  }
                  if (unlikely(cob_exception_code != 0))
                    {
                      /* PERFORM Default Error Handler */
                      frame_ptr++;
                      frame_ptr->perform_through = 1;
                      frame_ptr->return_address = &&l_238;
                      goto l_1;
                      l_238:
                      frame_ptr--;
                    }
                }
            }
            /* OCic.cbl:3220: MOVE */
            {
              memset (b_1070 + 115, 32, 32);
            }
          }
        else
          if (((int)cob_cmp (&f_1096, &c_229) == 0))
            {
              /* OCic.cbl:3222: IF */
              {
                if (((int)cob_cmp (&f_457, &cob_space) != 0))
                  {
                    /* OCic.cbl:3223: MOVE */
                    {
                      cob_move (&f_457, &f_392);
                    }
                    /* OCic.cbl:3224: MOVE */
                    {
                      memset (b_457, 32, 100);
                    }
                    /* OCic.cbl:3225: MOVE */
                    {
                      *(b_401 + 106) = 42;
                    }
                    /* OCic.cbl:3226: RELEASE */
                    cob_exception_code = 0;
                    {
                      cob_file_release (h_SORT_FILE);
                    }
                    if (unlikely(cob_exception_code != 0))
                      {
                        /* PERFORM Default Error Handler */
                        frame_ptr++;
                        frame_ptr->perform_through = 1;
                        frame_ptr->return_address = &&l_239;
                        goto l_1;
                        l_239:
                        frame_ptr--;
                      }
                  }
              }
              /* OCic.cbl:3228: MOVE */
              {
                memset (b_1070 + 115, 32, 32);
              }
            }
          else
            {
              /* OCic.cbl:3230: PERFORM */
              {
                /* PERFORM 361-Release-Ref */
                frame_ptr++;
                frame_ptr->perform_through = 114;
                frame_ptr->return_address = &&l_240;
                goto l_114;
                l_240:
                frame_ptr--;
              }
            }
  }

  if (frame_ptr->perform_through == 104)
    goto *frame_ptr->return_address;

  /* 351-MOVE */

  l_105:;
  /* OCic.cbl:3235: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_224) == 0))
      {
        /* OCic.cbl:3237: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_241;
          goto l_115;
          l_241:
          frame_ptr--;
        }
      }
    else
      {
        /* OCic.cbl:3239: PERFORM */
        {
          /* PERFORM 361-Release-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 114;
          frame_ptr->return_address = &&l_242;
          goto l_114;
          l_242:
          frame_ptr--;
        }
      }
  }

  if (frame_ptr->perform_through == 105)
    goto *frame_ptr->return_address;

  /* 351-MULTIPLY */

  l_106:;
  /* OCic.cbl:3244: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_230) == 0))
      {
        /* OCic.cbl:3246: PERFORM */
        {
          /* PERFORM 363-Set-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 116;
          frame_ptr->return_address = &&l_243;
          goto l_116;
          l_243:
          frame_ptr--;
        }
        /* OCic.cbl:3247: MOVE */
        {
          memcpy (b_457, b_401, 100);
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_223) == 0))
        {
          /* OCic.cbl:3249: MOVE */
          {
            cob_move (&f_457, &f_392);
          }
          /* OCic.cbl:3250: MOVE */
          {
            memset (b_457, 32, 100);
            *(b_401 + 106) = 32;
          }
          /* OCic.cbl:3252: RELEASE */
          cob_exception_code = 0;
          {
            cob_file_release (h_SORT_FILE);
          }
          if (unlikely(cob_exception_code != 0))
            {
              /* PERFORM Default Error Handler */
              frame_ptr++;
              frame_ptr->perform_through = 1;
              frame_ptr->return_address = &&l_244;
              goto l_1;
              l_244:
              frame_ptr--;
            }
          /* OCic.cbl:3253: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_245;
            goto l_115;
            l_245:
            frame_ptr--;
          }
        }
      else
        {
          /* OCic.cbl:3255: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_246;
            goto l_114;
            l_246:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 106)
    goto *frame_ptr->return_address;

  /* 351-PERFORM */

  l_107:;
  /* OCic.cbl:3260: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_231) == 0))
      {
        /* OCic.cbl:3262: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_247;
          goto l_115;
          l_247:
          frame_ptr--;
        }
        /* OCic.cbl:3263: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_232) == 0))
        {
          /* OCic.cbl:3265: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_248;
            goto l_115;
            l_248:
            frame_ptr--;
          }
          /* OCic.cbl:3266: MOVE */
          {
            memset (b_1070 + 115, 32, 32);
          }
        }
      else
        {
          /* OCic.cbl:3268: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_249;
            goto l_114;
            l_249:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 107)
    goto *frame_ptr->return_address;

  /* 351-SET */

  l_108:;
  /* OCic.cbl:3273: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_218) == 0))
      {
        /* OCic.cbl:3275: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_250;
          goto l_115;
          l_250:
          frame_ptr--;
        }
      }
    else
      {
        /* OCic.cbl:3277: PERFORM */
        {
          /* PERFORM 361-Release-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 114;
          frame_ptr->return_address = &&l_251;
          goto l_114;
          l_251:
          frame_ptr--;
        }
      }
  }

  if (frame_ptr->perform_through == 108)
    goto *frame_ptr->return_address;

  /* 351-STRING */

  l_109:;
  /* OCic.cbl:3282: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_202) == 0))
      {
        /* OCic.cbl:3284: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_252;
          goto l_115;
          l_252:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_233) == 0))
        {
          /* OCic.cbl:3286: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_253;
            goto l_115;
            l_253:
            frame_ptr--;
          }
        }
      else
        {
          /* OCic.cbl:3288: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_254;
            goto l_114;
            l_254:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 109)
    goto *frame_ptr->return_address;

  /* 351-SUBTRACT */

  l_110:;
  /* OCic.cbl:3293: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_223) == 0))
      {
        /* OCic.cbl:3295: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_255;
          goto l_115;
          l_255:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_234) == 0))
        {
          /* OCic.cbl:3297: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_256;
            goto l_115;
            l_256:
            frame_ptr--;
          }
        }
      else
        {
          /* OCic.cbl:3299: PERFORM */
          {
            /* PERFORM 361-Release-Ref */
            frame_ptr++;
            frame_ptr->perform_through = 114;
            frame_ptr->return_address = &&l_257;
            goto l_114;
            l_257:
            frame_ptr--;
          }
        }
  }

  if (frame_ptr->perform_through == 110)
    goto *frame_ptr->return_address;

  /* 351-TRANSFORM */

  l_111:;
  /* OCic.cbl:3304: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_221) == 0))
      {
        /* OCic.cbl:3306: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_258;
          goto l_115;
          l_258:
          frame_ptr--;
        }
        /* OCic.cbl:3307: MOVE */
        {
          memset (b_1070 + 115, 32, 32);
        }
      }
    else
      {
        /* OCic.cbl:3309: PERFORM */
        {
          /* PERFORM 361-Release-Ref */
          frame_ptr++;
          frame_ptr->perform_through = 114;
          frame_ptr->return_address = &&l_259;
          goto l_114;
          l_259:
          frame_ptr--;
        }
      }
  }

  if (frame_ptr->perform_through == 111)
    goto *frame_ptr->return_address;

  /* 351-UNSTRING */

  l_112:;
  /* OCic.cbl:3314: EVALUATE */
  {
    if (((int)cob_cmp (&f_1096, &c_202) == 0))
      {
        /* OCic.cbl:3316: PERFORM */
        {
          /* PERFORM 362-Release-Upd */
          frame_ptr++;
          frame_ptr->perform_through = 115;
          frame_ptr->return_address = &&l_260;
          goto l_115;
          l_260:
          frame_ptr--;
        }
      }
    else
      if (((int)cob_cmp (&f_1096, &c_235) == 0))
        {
          /* OCic.cbl:3318: PERFORM */
          {
            /* PERFORM 362-Release-Upd */
            frame_ptr++;
            frame_ptr->perform_through = 115;
            frame_ptr->return_address = &&l_261;
            goto l_115;
            l_261:
            frame_ptr--;
          }
        }
      else
        if (((int)cob_cmp (&f_1096, &c_236) == 0))
          {
            /* OCic.cbl:3320: PERFORM */
            {
              /* PERFORM 362-Release-Upd */
              frame_ptr++;
              frame_ptr->perform_through = 115;
              frame_ptr->return_address = &&l_262;
              goto l_115;
              l_262:
              frame_ptr--;
            }
          }
        else
          if (((int)cob_cmp (&f_1096, &c_233) == 0))
            {
              /* OCic.cbl:3322: PERFORM */
              {
                /* PERFORM 362-Release-Upd */
                frame_ptr++;
                frame_ptr->perform_through = 115;
                frame_ptr->return_address = &&l_263;
                goto l_115;
                l_263:
                frame_ptr--;
              }
            }
          else
            if (((int)cob_cmp (&f_1096, &c_228) == 0))
              {
                /* OCic.cbl:3324: PERFORM */
                {
                  /* PERFORM 362-Release-Upd */
                  frame_ptr++;
                  frame_ptr->perform_through = 115;
                  frame_ptr->return_address = &&l_264;
                  goto l_115;
                  l_264:
                  frame_ptr--;
                }
              }
            else
              {
                /* OCic.cbl:3326: PERFORM */
                {
                  /* PERFORM 361-Release-Ref */
                  frame_ptr++;
                  frame_ptr->perform_through = 114;
                  frame_ptr->return_address = &&l_265;
                  goto l_114;
                  l_265:
                  frame_ptr--;
                }
              }
  }

  if (frame_ptr->perform_through == 112)
    goto *frame_ptr->return_address;

  /* 360-Release-Def */

  l_113:;
  /* OCic.cbl:3331: MOVE */
  {
    memset (b_401, 32, 107);
  }
  /* OCic.cbl:3332: MOVE */
  {
    memcpy (b_401, b_1070 + 8, 15);
  }
  /* OCic.cbl:3333: MOVE */
  {
    memcpy (b_401 + 15, b_1070 + 70, 32);
  }
  /* OCic.cbl:3334: MOVE */
  {
    memcpy (b_401 + 47, b_1070 + 38, 32);
  }
  /* OCic.cbl:3335: MOVE */
  {
    memcpy (b_401 + 79, b_1070 + 23, 15);
  }
  /* OCic.cbl:3336: MOVE */
  {
    memcpy (b_401 + 94, b_1070 + 2, 6);
  }
  /* OCic.cbl:3337: MOVE */
  {
    memset (b_401 + 100, 48, 6);
  }
  /* OCic.cbl:3338: RELEASE */
  cob_exception_code = 0;
  {
    cob_file_release (h_SORT_FILE);
  }
  if (unlikely(cob_exception_code != 0))
    {
      /* PERFORM Default Error Handler */
      frame_ptr++;
      frame_ptr->perform_through = 1;
      frame_ptr->return_address = &&l_266;
      goto l_1;
      l_266:
      frame_ptr--;
    }

  if (frame_ptr->perform_through == 113)
    goto *frame_ptr->return_address;

  /* 361-Release-Ref */

  l_114:;
  /* OCic.cbl:3342: PERFORM */
  {
    /* PERFORM 364-Set-Ref */
    frame_ptr++;
    frame_ptr->perform_through = 117;
    frame_ptr->return_address = &&l_267;
    goto l_117;
    l_267:
    frame_ptr--;
  }
  /* OCic.cbl:3343: RELEASE */
  cob_exception_code = 0;
  {
    cob_file_release (h_SORT_FILE);
  }
  if (unlikely(cob_exception_code != 0))
    {
      /* PERFORM Default Error Handler */
      frame_ptr++;
      frame_ptr->perform_through = 1;
      frame_ptr->return_address = &&l_268;
      goto l_1;
      l_268:
      frame_ptr--;
    }

  if (frame_ptr->perform_through == 114)
    goto *frame_ptr->return_address;

  /* 362-Release-Upd */

  l_115:;
  /* OCic.cbl:3347: PERFORM */
  {
    /* PERFORM 363-Set-Upd */
    frame_ptr++;
    frame_ptr->perform_through = 116;
    frame_ptr->return_address = &&l_269;
    goto l_116;
    l_269:
    frame_ptr--;
  }
  /* OCic.cbl:3348: RELEASE */
  cob_exception_code = 0;
  {
    cob_file_release (h_SORT_FILE);
  }
  if (unlikely(cob_exception_code != 0))
    {
      /* PERFORM Default Error Handler */
      frame_ptr++;
      frame_ptr->perform_through = 1;
      frame_ptr->return_address = &&l_270;
      goto l_1;
      l_270:
      frame_ptr--;
    }

  if (frame_ptr->perform_through == 115)
    goto *frame_ptr->return_address;

  /* 363-Set-Upd */

  l_116:;
  /* OCic.cbl:3352: MOVE */
  {
    memset (b_401, 32, 107);
  }
  /* OCic.cbl:3353: MOVE */
  {
    memcpy (b_401, b_1070 + 8, 15);
  }
  /* OCic.cbl:3354: MOVE */
  {
    memcpy (b_401 + 15, b_1070 + 70, 32);
  }
  /* OCic.cbl:3355: MOVE */
  {
    memcpy (b_401 + 47, b_1070 + 38, 32);
  }
  /* OCic.cbl:3356: MOVE */
  {
    memcpy (b_401 + 79, b_1070 + 23, 15);
  }
  /* OCic.cbl:3357: MOVE */
  {
    memcpy (b_401 + 100, b_1070 + 2, 6);
  }
  /* OCic.cbl:3358: MOVE */
  {
    *(b_401 + 106) = 42;
  }

  if (frame_ptr->perform_through == 116)
    goto *frame_ptr->return_address;

  /* 364-Set-Ref */

  l_117:;
  /* OCic.cbl:3362: MOVE */
  {
    memset (b_401, 32, 107);
  }
  /* OCic.cbl:3363: MOVE */
  {
    memcpy (b_401, b_1070 + 8, 15);
  }
  /* OCic.cbl:3364: MOVE */
  {
    memcpy (b_401 + 15, b_1070 + 70, 32);
  }
  /* OCic.cbl:3365: MOVE */
  {
    memcpy (b_401 + 47, b_1070 + 38, 32);
  }
  /* OCic.cbl:3366: MOVE */
  {
    memcpy (b_401 + 79, b_1070 + 23, 15);
  }
  /* OCic.cbl:3367: MOVE */
  {
    memcpy (b_401 + 100, b_1070 + 2, 6);
  }

  if (frame_ptr->perform_through == 117)
    goto *frame_ptr->return_address;

  /* EXIT SECTION 81 */

  l_81:;

  if (frame_ptr->perform_through == 78)
    goto *frame_ptr->return_address;

  /* 400-Produce-Xref-Listing SECTION */

  l_118:;

  /* 401-Init */

  /* OCic.cbl:3372: MOVE */
  {
    memset (b_416, 32, 136);
    memset (b_443, 32, 47);
  }
  /* OCic.cbl:3374: MOVE */
  {
    (*(int *)(b_458)) = 0;
    (*(int *)(b_460)) = 0;
  }
  /* OCic.cbl:3376: MOVE */
  {
    *(b_433) = 78;
  }

  /* 402-Process-Sorted-Recs */

  /* OCic.cbl:3380: PERFORM */
  {
    while (1)
      {
        {
          /* OCic.cbl:3381: RETURN */
          cob_exception_code = 0;
          {
            cob_file_return (h_SORT_FILE);
          }
          if (unlikely(cob_exception_code != 0))
            {
              if (cob_exception_code == 0x0501)
                {
                  {
                    /* OCic.cbl:3382: EXIT */
                    {
                      goto l_121;
                    }
                  }
                }
              else
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_271;
                  goto l_1;
                  l_271:
                  frame_ptr--;
                }
            }
          /* OCic.cbl:3384: IF */
          {
            if ((((int)memcmp (b_401, b_443, 15) != 0) || ((int)memcmp (b_401 + 15, b_443 + 15, 32) != 0)))
              {
                /* OCic.cbl:3386: MOVE */
                {
                  *(b_433) = 78;
                }
                /* OCic.cbl:3387: IF */
                {
                  if (((int)cob_cmp (&f_416, &cob_space) != 0))
                    {
                      /* OCic.cbl:3388: PERFORM */
                      {
                        /* PERFORM 410-Generate-Report-Line */
                        frame_ptr++;
                        frame_ptr->perform_through = 124;
                        frame_ptr->return_address = &&l_272;
                        goto l_124;
                        l_272:
                        frame_ptr--;
                      }
                    }
                }
                /* OCic.cbl:3390: IF */
                {
                  if (((int)memcmp (b_401, b_443, 15) != 0))
                    {
                      /* OCic.cbl:3391: MOVE */
                      {
                        (*(int *)(b_460)) = 0;
                      }
                    }
                }
                /* OCic.cbl:3393: MOVE */
                {
                  memcpy (b_443, b_401, 15);
                }
                /* OCic.cbl:3394: MOVE */
                {
                  memcpy (b_443 + 15, b_401 + 15, 32);
                }
              }
          }
          /* OCic.cbl:3396: IF */
          {
            if (((((int)memcmp (b_401 + 15, b_443 + 15, 32) == 0) && ((int)cob_cmp (&f_397, &cob_space) != 0)) && ((int)cob_cmp (&f_416, &cob_space) != 0)))
              {
                /* OCic.cbl:3399: MOVE */
                {
                  *(b_433) = 89;
                }
                /* OCic.cbl:3400: PERFORM */
                {
                  /* PERFORM 410-Generate-Report-Line */
                  frame_ptr++;
                  frame_ptr->perform_through = 124;
                  frame_ptr->return_address = &&l_273;
                  goto l_124;
                  l_273:
                  frame_ptr--;
                }
                /* OCic.cbl:3401: MOVE */
                {
                  (*(int *)(b_458)) = 0;
                }
                /* OCic.cbl:3402: MOVE */
                {
                  memcpy (b_416, b_401, 15);
                }
                /* OCic.cbl:3403: MOVE */
                {
                  memcpy (b_416 + 16, "  (Duplicate Definition)        ", 32);
                }
                /* OCic.cbl:3404: MOVE */
                {
                  memcpy (b_416 + 56, b_401 + 79, 15);
                }
                /* OCic.cbl:3405: MOVE */
                {
                  cob_move (&f_397, &f_421);
                }
                /* OCic.cbl:3406: EXIT */
                {
                  goto l_122;
                }
              }
          }
          /* OCic.cbl:3408: IF */
          {
            if (((((int)memcmp (b_401 + 15, b_443 + 15, 32) == 0) && ((int)cob_cmp (&f_397, &cob_space) == 0)) && ((int)(int)(*(b_433) - 89) == 0)))
              {
                /* OCic.cbl:3411: MOVE */
                {
                  *(b_433) = 78;
                }
                /* OCic.cbl:3412: PERFORM */
                {
                  /* PERFORM 410-Generate-Report-Line */
                  frame_ptr++;
                  frame_ptr->perform_through = 124;
                  frame_ptr->return_address = &&l_274;
                  goto l_124;
                  l_274:
                  frame_ptr--;
                }
                /* OCic.cbl:3413: MOVE */
                {
                  (*(int *)(b_458)) = 0;
                }
                /* OCic.cbl:3414: MOVE */
                {
                  memcpy (b_416, b_401, 15);
                }
                /* OCic.cbl:3415: MOVE */
                {
                  memcpy (b_416 + 16, "  (Duplicate References)        ", 32);
                }
              }
          }
          /* OCic.cbl:3417: IF */
          {
            if (((int)cob_cmp (&f_416, &cob_space) == 0))
              {
                /* OCic.cbl:3418: MOVE */
                {
                  memcpy (b_416, b_401, 15);
                }
                /* OCic.cbl:3419: MOVE */
                {
                  memcpy (b_416 + 16, b_401 + 47, 32);
                }
                /* OCic.cbl:3420: MOVE */
                {
                  memcpy (b_416 + 56, b_401 + 79, 15);
                }
                /* OCic.cbl:3421: IF */
                {
                  if (((int)cob_cmp (&f_397, &cob_space) != 0))
                    {
                      /* OCic.cbl:3422: MOVE */
                      {
                        cob_move (&f_397, &f_421);
                      }
                    }
                }
              }
          }
          /* OCic.cbl:3425: IF */
          {
            if (((int)cob_cmp (&f_398, &c_237) >  0))
              {
                /* OCic.cbl:3426: ADD */
                {
                  (*(int *)(b_458)) = ((*(int *)(b_458)) + 1);
                }
                /* OCic.cbl:3427: IF */
                {
                  if (((int)cob_cmp_s32_binary (b_458, 8) >  0))
                    {
                      /* OCic.cbl:3428: PERFORM */
                      {
                        /* PERFORM 410-Generate-Report-Line */
                        frame_ptr++;
                        frame_ptr->perform_through = 124;
                        frame_ptr->return_address = &&l_275;
                        goto l_124;
                        l_275:
                        frame_ptr--;
                      }
                      /* OCic.cbl:3429: MOVE */
                      {
                        (*(int *)(b_458)) = 1;
                      }
                    }
                }
                /* OCic.cbl:3431: MOVE */
                {
                  cob_move (&f_399, (f0.size = 6, f0.data = b_416 + 72 + 8 * ((*(int *)(b_458)) - 1), f0.attr = &a_8, &f0));
                }
                /* OCic.cbl:3432: MOVE */
                {
                  *(b_416 + 78 + 8 * ((*(int *)(b_458)) - 1)) = *(b_401 + 106);
                }
              }
          }
        }

        /* EXIT PERFORM CYCLE 122 */

        l_122:;
      }

    /* EXIT PERFORM 121 */

    l_121:;
  }
  /* OCic.cbl:3435: IF */
  {
    if (((int)cob_cmp (&f_416, &cob_space) != 0))
      {
        /* OCic.cbl:3436: PERFORM */
        {
          /* PERFORM 410-Generate-Report-Line */
          frame_ptr++;
          frame_ptr->perform_through = 124;
          frame_ptr->return_address = &&l_276;
          goto l_124;
          l_276:
          frame_ptr--;
        }
      }
  }
  /* OCic.cbl:3438: EXIT */
  {
    goto l_123;
  }

  /* 410-Generate-Report-Line */

  l_124:;
  /* OCic.cbl:3442: IF */
  {
    if (((int)cob_cmp_s32_binary (b_460, 1) <  0))
      {
        /* OCic.cbl:3443: IF */
        {
          if (((int)(int)(*(b_433 + 1) - 89) == 0))
            {
              /* OCic.cbl:3444: MOVE */
              {
                *(b_433 + 1) = 78;
              }
              /* OCic.cbl:3445: WRITE */
              cob_exception_code = 0;
              {
                memcpy (b_391, b_449, 135);
                cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_277;
                  goto l_1;
                  l_277:
                  frame_ptr--;
                }
            }
          else
            {
              /* OCic.cbl:3447: MOVE */
              {
                memset (b_391, 32, 135);
              }
              /* OCic.cbl:3448: WRITE */
              cob_exception_code = 0;
              {
                cob_write (h_REPORT_FILE, &f_390, 2228224, NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_278;
                  goto l_1;
                  l_278:
                  frame_ptr--;
                }
              /* OCic.cbl:3449: MOVE */
              {
                memset (b_391, 32, 135);
              }
              /* OCic.cbl:3450: WRITE */
              cob_exception_code = 0;
              {
                cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_279;
                  goto l_1;
                  l_279:
                  frame_ptr--;
                }
              /* OCic.cbl:3451: WRITE */
              cob_exception_code = 0;
              {
                memcpy (b_391, b_449, 135);
                cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_280;
                  goto l_1;
                  l_280:
                  frame_ptr--;
                }
            }
        }
        /* OCic.cbl:3453: WRITE */
        cob_exception_code = 0;
        {
          memcpy (b_391, b_452, 135);
          cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
        }
        if (unlikely(cob_exception_code != 0))
          {
            /* PERFORM Default Error Handler */
            frame_ptr++;
            frame_ptr->perform_through = 1;
            frame_ptr->return_address = &&l_281;
            goto l_1;
            l_281:
            frame_ptr--;
          }
        /* OCic.cbl:3454: WRITE */
        cob_exception_code = 0;
        {
          cob_move (&f_454, &f_390);
          cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
        }
        if (unlikely(cob_exception_code != 0))
          {
            /* PERFORM Default Error Handler */
            frame_ptr++;
            frame_ptr->perform_through = 1;
            frame_ptr->return_address = &&l_282;
            goto l_1;
            l_282:
            frame_ptr--;
          }
        /* OCic.cbl:3455: WRITE */
        cob_exception_code = 0;
        {
          memcpy (b_391, b_456, 135);
          cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
        }
        if (unlikely(cob_exception_code != 0))
          {
            /* PERFORM Default Error Handler */
            frame_ptr++;
            frame_ptr->perform_through = 1;
            frame_ptr->return_address = &&l_283;
            goto l_1;
            l_283:
            frame_ptr--;
          }
        /* OCic.cbl:3456: COMPUTE */
        {
          {
            {
              cob_decimal_set_int (&d0, (*(int *)(b_461)));
              cob_decimal_set_int (&d1, 4);
              cob_decimal_sub (&d0, &d1);
              cob_decimal_get_field (&d0, &f_460, 0);
            }
          }
        }
      }
  }
  /* OCic.cbl:3460: WRITE */
  cob_exception_code = 0;
  {
    memcpy (b_391, b_416, 135);
    cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
  }
  if (unlikely(cob_exception_code != 0))
    {
      /* PERFORM Default Error Handler */
      frame_ptr++;
      frame_ptr->perform_through = 1;
      frame_ptr->return_address = &&l_284;
      goto l_1;
      l_284:
      frame_ptr--;
    }
  /* OCic.cbl:3461: MOVE */
  {
    memset (b_416, 32, 136);
  }
  /* OCic.cbl:3462: MOVE */
  {
    (*(int *)(b_458)) = 0;
  }
  /* OCic.cbl:3463: SUBTRACT */
  {
    (*(int *)(b_460)) = ((*(int *)(b_460)) - 1);
  }

  if (frame_ptr->perform_through == 124)
    goto *frame_ptr->return_address;

  /* EXIT SECTION 123 */

  l_123:;

  if (frame_ptr->perform_through == 118)
    goto *frame_ptr->return_address;

  /* 500-Produce-Source-Listing SECTION */

  l_125:;

  /* 501-Generate-Source-Listing */

  /* OCic.cbl:3468: OPEN */
  {
    cob_exception_code = 0;
    {
      cob_open (h_SOURCE_CODE, 1, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_285;
        goto l_1;
        l_285:
        frame_ptr--;
      }
    cob_exception_code = 0;
    {
      cob_open (h_EXPAND_CODE, 1, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_286;
        goto l_1;
        l_286:
        frame_ptr--;
      }
  }
  /* OCic.cbl:3470: MOVE */
  {
    memset (b_1068, 48, 6);
  }
  /* OCic.cbl:3471: PERFORM */
  {
    while (1)
      {
        {
          /* OCic.cbl:3472: READ */
          cob_exception_code = 0;
          {
            cob_read (h_EXPAND_CODE, 0, NULL, 1);
          }
          if (unlikely(cob_exception_code != 0))
            {
              if (cob_exception_code == 0x0501)
                {
                  {
                    /* OCic.cbl:3473: EXIT */
                    {
                      goto l_127;
                    }
                  }
                }
              else
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_287;
                  goto l_1;
                  l_287:
                  frame_ptr--;
                }
            }
          /* OCic.cbl:3475: IF */
          {
            if (((int)(int)(*(b_389) - 35) == 0))
              {
                /* OCic.cbl:3476: PERFORM */
                {
                  /* PERFORM 510-Control-Record */
                  frame_ptr++;
                  frame_ptr->perform_through = 129;
                  frame_ptr->return_address = &&l_288;
                  goto l_129;
                  l_288:
                  frame_ptr--;
                }
              }
            else
              {
                /* OCic.cbl:3478: PERFORM */
                {
                  /* PERFORM 520-Expand-Code-Record */
                  frame_ptr++;
                  frame_ptr->perform_through = 130;
                  frame_ptr->return_address = &&l_289;
                  goto l_130;
                  l_289:
                  frame_ptr--;
                }
              }
          }
        }
      }

    /* EXIT PERFORM 127 */

    l_127:;
  }
  /* OCic.cbl:3481: CLOSE */
  {
    cob_exception_code = 0;
    {
      cob_close (h_SOURCE_CODE, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_290;
        goto l_1;
        l_290:
        frame_ptr--;
      }
    cob_exception_code = 0;
    {
      cob_close (h_EXPAND_CODE, 0, NULL);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM Default Error Handler */
        frame_ptr++;
        frame_ptr->perform_through = 1;
        frame_ptr->return_address = &&l_291;
        goto l_1;
        l_291:
        frame_ptr--;
      }
  }
  /* OCic.cbl:3483: EXIT */
  {
    goto l_128;
  }

  /* 510-Control-Record */

  l_129:;
  /* OCic.cbl:3487: UNSTRING */
  {
    cob_unstring_init (&f_385, 0, 1);
    cob_unstring_delimited (&c_91, 0);
    cob_unstring_into (&f_464, 0, 0);
    cob_unstring_into (&f_466, 0, 0);
    cob_unstring_into (&f_429, 0, 0);
    cob_unstring_finish ();
  }
  /* OCic.cbl:3491: IF */
  {
    if (((int)cob_cmp (cob_intr_trim (0, 0, &f_466, 2), cob_intr_trim (0, 0, &f_467, 2)) == 0))
      {
        /* OCic.cbl:3492: SET */
        {
          *(b_433 + 2) = 77;
        }
        /* OCic.cbl:3493: IF */
        {
          if (((int)cob_cmp_numdisp (b_1068, 6, 0) >  0))
            {
              /* OCic.cbl:3494: READ */
              cob_exception_code = 0;
              {
                cob_read (h_EXPAND_CODE, 0, NULL, 1);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_292;
                  goto l_1;
                  l_292:
                  frame_ptr--;
                }
            }
        }
      }
    else
      {
        /* OCic.cbl:3497: SET */
        {
          *(b_433 + 2) = 67;
        }
      }
  }

  if (frame_ptr->perform_through == 129)
    goto *frame_ptr->return_address;

  /* 520-Expand-Code-Record */

  l_130:;
  /* OCic.cbl:3502: IF */
  {
    if (((int)(int)(*(b_433 + 2) - 77) == 0))
      {
        /* OCic.cbl:3503: ADD */
        {
          cob_add (&f_1081, &c_70, 2);
        }
        /* OCic.cbl:3504: READ */
        cob_exception_code = 0;
        {
          cob_read (h_SOURCE_CODE, 0, NULL, 1);
        }
        if (unlikely(cob_exception_code != 0))
          {
            if (cob_exception_code == 0x0501)
              {
                {
                  /* OCic.cbl:3504: NEXT SENTENCE */
                  goto l_131;
                }
              }
            else
              {
                /* PERFORM Default Error Handler */
                frame_ptr++;
                frame_ptr->perform_through = 1;
                frame_ptr->return_address = &&l_293;
                goto l_1;
                l_293:
                frame_ptr--;
              }
          }
        /* OCic.cbl:3505: ADD */
        {
          cob_add (&f_1068, &c_70, 2);
        }
        /* OCic.cbl:3506: MOVE */
        {
          memset (b_412, 32, 135);
        }
        /* OCic.cbl:3507: MOVE */
        {
          cob_move (&f_1068, &f_413);
        }
        /* OCic.cbl:3508: MOVE */
        {
          memcpy (b_412 + 7, b_408, 128);
        }
        /* OCic.cbl:3509: IF */
        {
          if (((int)(int)(*(b_408 + 6) - 47) == 0))
            {
              /* OCic.cbl:3510: MOVE */
              {
                (*(int *)(b_460)) = 0;
              }
            }
        }
        /* OCic.cbl:3512: PERFORM */
        {
          /* PERFORM 530-Generate-Source-Line */
          frame_ptr++;
          frame_ptr->perform_through = 132;
          frame_ptr->return_address = &&l_294;
          goto l_132;
          l_294:
          frame_ptr--;
        }
        /* OCic.cbl:3513: IF */
        {
          if (((int)cob_cmp (&f_407, &cob_space) != 0))
            {
              /* OCic.cbl:3514: MOVE */
              {
                memset (b_412, 32, 135);
              }
              /* OCic.cbl:3515: MOVE */
              {
                memcpy (b_412 + 7, b_408 + 128, 128);
              }
              /* OCic.cbl:3516: PERFORM */
              {
                /* PERFORM 530-Generate-Source-Line */
                frame_ptr++;
                frame_ptr->perform_through = 132;
                frame_ptr->return_address = &&l_295;
                goto l_132;
                l_295:
                frame_ptr--;
              }
            }
        }
      }
    else
      {
        /* OCic.cbl:3519: IF */
        {
          if (((int)cob_cmp (&f_383, &cob_space) != 0))
            {
              /* OCic.cbl:3520: MOVE */
              {
                memset (b_412, 32, 135);
              }
              /* OCic.cbl:3521: MOVE */
              {
                memcpy (b_412 + 7, b_389, 128);
              }
              /* OCic.cbl:3522: PERFORM */
              {
                /* PERFORM 530-Generate-Source-Line */
                frame_ptr++;
                frame_ptr->perform_through = 132;
                frame_ptr->return_address = &&l_296;
                goto l_132;
                l_296:
                frame_ptr--;
              }
              /* OCic.cbl:3523: IF */
              {
                if (((int)cob_cmp (&f_388, &cob_space) != 0))
                  {
                    /* OCic.cbl:3524: MOVE */
                    {
                      memset (b_412, 32, 135);
                    }
                    /* OCic.cbl:3525: MOVE */
                    {
                      memcpy (b_412 + 7, b_389 + 128, 128);
                    }
                    /* OCic.cbl:3526: PERFORM */
                    {
                      /* PERFORM 530-Generate-Source-Line */
                      frame_ptr++;
                      frame_ptr->perform_through = 132;
                      frame_ptr->return_address = &&l_297;
                      goto l_132;
                      l_297:
                      frame_ptr--;
                    }
                  }
              }
            }
        }
      }
  }

  /* L$0 */

  l_131:;

  if (frame_ptr->perform_through == 130)
    goto *frame_ptr->return_address;

  /* 530-Generate-Source-Line */

  l_132:;
  /* OCic.cbl:3533: IF */
  {
    if (((int)cob_cmp_s32_binary (b_460, 1) <  0))
      {
        /* OCic.cbl:3534: IF */
        {
          if (((int)(int)(*(b_433 + 1) - 89) == 0))
            {
              /* OCic.cbl:3535: MOVE */
              {
                *(b_433 + 1) = 78;
              }
              /* OCic.cbl:3536: WRITE */
              cob_exception_code = 0;
              {
                memcpy (b_391, b_446, 135);
                cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_298;
                  goto l_1;
                  l_298:
                  frame_ptr--;
                }
            }
          else
            {
              /* OCic.cbl:3538: MOVE */
              {
                memset (b_391, 32, 135);
              }
              /* OCic.cbl:3539: WRITE */
              cob_exception_code = 0;
              {
                cob_write (h_REPORT_FILE, &f_390, 2228224, NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_299;
                  goto l_1;
                  l_299:
                  frame_ptr--;
                }
              /* OCic.cbl:3540: MOVE */
              {
                memset (b_391, 32, 135);
              }
              /* OCic.cbl:3541: WRITE */
              cob_exception_code = 0;
              {
                cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_300;
                  goto l_1;
                  l_300:
                  frame_ptr--;
                }
              /* OCic.cbl:3542: WRITE */
              cob_exception_code = 0;
              {
                memcpy (b_391, b_446, 135);
                cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
              }
              if (unlikely(cob_exception_code != 0))
                {
                  /* PERFORM Default Error Handler */
                  frame_ptr++;
                  frame_ptr->perform_through = 1;
                  frame_ptr->return_address = &&l_301;
                  goto l_1;
                  l_301:
                  frame_ptr--;
                }
            }
        }
        /* OCic.cbl:3544: WRITE */
        cob_exception_code = 0;
        {
          memcpy (b_391, b_452, 135);
          cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
        }
        if (unlikely(cob_exception_code != 0))
          {
            /* PERFORM Default Error Handler */
            frame_ptr++;
            frame_ptr->perform_through = 1;
            frame_ptr->return_address = &&l_302;
            goto l_1;
            l_302:
            frame_ptr--;
          }
        /* OCic.cbl:3545: WRITE */
        cob_exception_code = 0;
        {
          cob_move (&f_453, &f_390);
          cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
        }
        if (unlikely(cob_exception_code != 0))
          {
            /* PERFORM Default Error Handler */
            frame_ptr++;
            frame_ptr->perform_through = 1;
            frame_ptr->return_address = &&l_303;
            goto l_1;
            l_303:
            frame_ptr--;
          }
        /* OCic.cbl:3546: WRITE */
        cob_exception_code = 0;
        {
          memcpy (b_391, b_455, 135);
          cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
        }
        if (unlikely(cob_exception_code != 0))
          {
            /* PERFORM Default Error Handler */
            frame_ptr++;
            frame_ptr->perform_through = 1;
            frame_ptr->return_address = &&l_304;
            goto l_1;
            l_304:
            frame_ptr--;
          }
        /* OCic.cbl:3547: COMPUTE */
        {
          {
            {
              cob_decimal_set_int (&d0, (*(int *)(b_461)));
              cob_decimal_set_int (&d1, 4);
              cob_decimal_sub (&d0, &d1);
              cob_decimal_get_field (&d0, &f_460, 0);
            }
          }
        }
      }
  }
  /* OCic.cbl:3551: WRITE */
  cob_exception_code = 0;
  {
    memcpy (b_391, b_412, 135);
    cob_write (h_REPORT_FILE, &f_390, (2162688 + 1), NULL);
  }
  if (unlikely(cob_exception_code != 0))
    {
      /* PERFORM Default Error Handler */
      frame_ptr++;
      frame_ptr->perform_through = 1;
      frame_ptr->return_address = &&l_305;
      goto l_1;
      l_305:
      frame_ptr--;
    }
  /* OCic.cbl:3552: MOVE */
  {
    memset (b_412, 32, 135);
  }
  /* OCic.cbl:3553: SUBTRACT */
  {
    (*(int *)(b_460)) = ((*(int *)(b_460)) - 1);
  }

  if (frame_ptr->perform_through == 132)
    goto *frame_ptr->return_address;

  /* EXIT SECTION 128 */

  l_128:;

  if (frame_ptr->perform_through == 125)
    goto *frame_ptr->return_address;

  /* Program exit */

  exit_program:

  /* Pop module stack */
  cob_current_module = cob_current_module->next;

  /* Program return */
  return (*(int *) (b_379));


  /* Default Error Handler */

  l_1:;

  if (!(cob_error_file->flag_select_features & COB_SELECT_FILE_STATUS)) {
        cob_default_error_handle ();
        cob_stop_run (1);
  }

  if (frame_ptr->perform_through == 1)
    goto *frame_ptr->return_address;

  cob_fatal_error (COB_FERROR_CODEGEN);

}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 42 of file OCic.c.

{
  cob_init (argc, argv);
  cob_stop_run (OCic ());
}

Here is the call graph for this function:

int OCic ( )

Definition at line 51 of file OCic.c.

{
  return OCic1 (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int OCic1 ( const int  entry) [static]

Definition at line 57 of file OCic.c.

{
  /* Local variables */
  #include "OCic.c.l1.h"

  static int initialized = 0;
  static cob_field *cob_user_parameters[COB_MAX_FIELD_PARAMS];
  static struct cob_module module = { NULL, NULL, &f_352, NULL, cob_user_parameters, 0, '.', '$', ',', 1, 1, 1, 0 };

  /* Start of function code */

  /* CANCEL callback handling */
  if (unlikely(entry < 0)) {
        if (!initialized) {
                return 0;
        }
        cob_close (h_BAT_FILE, 0, NULL);
        cob_close (h_COBC_OUTPUT, 0, NULL);
        cob_close (h_SOURCE_CODE, 0, NULL);
        initialized = 0;
        return 0;
  }

  /* Initialize frame stack */
  frame_ptr = &frame_stack[0];
  frame_ptr->perform_through = 0;

  /* Push module stack */
  module.next = cob_current_module;
  cob_current_module = &module;

  /* Initialize program */
  if (unlikely(initialized == 0))
    {
      if (!cob_initialized) {
        cob_fatal_error (COB_FERROR_INITIALIZED);
      }
      cob_check_version (COB_SOURCE_FILE, COB_PACKAGE_VERSION, COB_PATCH_LEVEL);
      (*(int *) (b_1)) = 0;
      memset (b_92, 32, 256);
      memset (b_93, 32, 512);
      memset (b_94, 32, 256);
      memset (b_95, 32, 256);
      memset (b_96, 32, 256);
      memset (b_97, 32, 12);
      memset (b_98, 48, 28);
      *(unsigned char *)(b_106) = 32;
      *(unsigned char *)(b_107) = 32;
      memset (b_108, 32, 256);
      memset (b_109, 32, 256);
      memcpy (b_111, "Status Code: ", 13);
      memset (b_111 + 13, 48, 2);
      memcpy (b_111 + 15, ", Meaning: ", 11);
      memset (b_111 + 26, 32, 25);
      memset (b_116, 32, 8);
      memset (b_143, 32, 80);
      memset (b_144, 0, 4);
      memset (b_145, 0, 4);
      memset (b_146, 0, 4);
      memset (b_147, 0, 4);
      cob_move (&cob_space, &f_148);
      memset (b_149, 0, 4);
      memset (b_154, 32, 7);
      memset (b_155, 32, 80);
      *(unsigned char *)(b_156) = 32;
      memset (b_157, 32, 256);
      memset (b_158, 32, 30);
      memset (b_159, 32, 40);
      memset (b_160, 32, 31);
      memset (b_162, 32, 80);
      memset (b_166, 32, 12);
      memset (b_176, 32, 256);
      memset (b_177, 32, 256);
      memset (b_182, 32, 75);
      *(unsigned char *) (b_182 + 75) = 32;
      *(unsigned char *) (b_182 + 76) = 32;
      *(unsigned char *) (b_182 + 77) = 32;
      *(unsigned char *) (b_182 + 78) = 62;
      *(unsigned char *) (b_182 + 79) = 32;
      *(unsigned char *) (b_182 + 80) = 32;
      *(unsigned char *) (b_182 + 81) = 32;
      memset (b_182 + 82, 32, 75);
      *(unsigned char *) (b_182 + 157) = 78;
      *(unsigned char *) (b_182 + 158) = 78;
      *(unsigned char *) (b_182 + 159) = 78;
      *(unsigned char *) (b_182 + 160) = 78;
      *(unsigned char *) (b_182 + 161) = 78;
      *(unsigned char *) (b_182 + 162) = 89;
      *(unsigned char *) (b_182 + 163) = 65;
      *(unsigned char *) (b_182 + 164) = 78;
      *(unsigned char *) (b_182 + 165) = 78;
      memset (b_203, 0, 4);
      memset (b_352, 48, 4);

      if (!h_BAT_FILE)
      {
        h_BAT_FILE = cob_malloc (sizeof(cob_file));
      }
      h_BAT_FILE->select_name = (const char *)"Bat-File";
      h_BAT_FILE->file_status = h_BAT_FILE_status;
      memset (h_BAT_FILE_status, '0', 2);
      h_BAT_FILE->assign = &f_92;
      h_BAT_FILE->record = &f_6;
      h_BAT_FILE->record_size = NULL;
      h_BAT_FILE->record_min = 0;
      h_BAT_FILE->record_max = 2048;
      h_BAT_FILE->nkeys = 0;
      h_BAT_FILE->keys = NULL;
      h_BAT_FILE->file = NULL;
      h_BAT_FILE->organization = 1;
      h_BAT_FILE->access_mode = 1;
      h_BAT_FILE->lock_mode = 0;
      h_BAT_FILE->open_mode = 0;
      h_BAT_FILE->flag_optional = 0;
      h_BAT_FILE->last_open_mode = 0;
      h_BAT_FILE->special = 0;
      h_BAT_FILE->flag_nonexistent = 0;
      h_BAT_FILE->flag_end_of_file = 0;
      h_BAT_FILE->flag_begin_of_file = 0;
      h_BAT_FILE->flag_first_read = 0;
      h_BAT_FILE->flag_read_done = 0;
      h_BAT_FILE->flag_select_features = 0;
      h_BAT_FILE->flag_needs_nl = 0;
      h_BAT_FILE->flag_needs_top = 0;
      h_BAT_FILE->file_version = 0;
      if (!h_COBC_OUTPUT)
      {
        h_COBC_OUTPUT = cob_malloc (sizeof(cob_file));
      }
      h_COBC_OUTPUT->select_name = (const char *)"Cobc-Output";
      h_COBC_OUTPUT->file_status = h_COBC_OUTPUT_status;
      memset (h_COBC_OUTPUT_status, '0', 2);
      h_COBC_OUTPUT->assign = &f_95;
      h_COBC_OUTPUT->record = &f_8;
      h_COBC_OUTPUT->record_size = NULL;
      h_COBC_OUTPUT->record_min = 0;
      h_COBC_OUTPUT->record_max = 256;
      h_COBC_OUTPUT->nkeys = 0;
      h_COBC_OUTPUT->keys = NULL;
      h_COBC_OUTPUT->file = NULL;
      h_COBC_OUTPUT->organization = 1;
      h_COBC_OUTPUT->access_mode = 1;
      h_COBC_OUTPUT->lock_mode = 0;
      h_COBC_OUTPUT->open_mode = 0;
      h_COBC_OUTPUT->flag_optional = 0;
      h_COBC_OUTPUT->last_open_mode = 0;
      h_COBC_OUTPUT->special = 0;
      h_COBC_OUTPUT->flag_nonexistent = 0;
      h_COBC_OUTPUT->flag_end_of_file = 0;
      h_COBC_OUTPUT->flag_begin_of_file = 0;
      h_COBC_OUTPUT->flag_first_read = 0;
      h_COBC_OUTPUT->flag_read_done = 0;
      h_COBC_OUTPUT->flag_select_features = 0;
      h_COBC_OUTPUT->flag_needs_nl = 0;
      h_COBC_OUTPUT->flag_needs_top = 0;
      h_COBC_OUTPUT->file_version = 0;
      if (!h_SOURCE_CODE)
      {
        h_SOURCE_CODE = cob_malloc (sizeof(cob_file));
      }
      h_SOURCE_CODE->select_name = (const char *)"Source-Code";
      h_SOURCE_CODE->file_status = h_SOURCE_CODE_status;
      memset (h_SOURCE_CODE_status, '0', 2);
      h_SOURCE_CODE->assign = &f_109;
      h_SOURCE_CODE->record = &f_10;
      h_SOURCE_CODE->record_size = NULL;
      h_SOURCE_CODE->record_min = 0;
      h_SOURCE_CODE->record_max = 80;
      h_SOURCE_CODE->nkeys = 0;
      h_SOURCE_CODE->keys = NULL;
      h_SOURCE_CODE->file = NULL;
      h_SOURCE_CODE->organization = 1;
      h_SOURCE_CODE->access_mode = 1;
      h_SOURCE_CODE->lock_mode = 0;
      h_SOURCE_CODE->open_mode = 0;
      h_SOURCE_CODE->flag_optional = 0;
      h_SOURCE_CODE->last_open_mode = 0;
      h_SOURCE_CODE->special = 0;
      h_SOURCE_CODE->flag_nonexistent = 0;
      h_SOURCE_CODE->flag_end_of_file = 0;
      h_SOURCE_CODE->flag_begin_of_file = 0;
      h_SOURCE_CODE->flag_first_read = 0;
      h_SOURCE_CODE->flag_read_done = 0;
      h_SOURCE_CODE->flag_select_features = 1;
      h_SOURCE_CODE->flag_needs_nl = 0;
      h_SOURCE_CODE->flag_needs_top = 0;
      h_SOURCE_CODE->file_version = 0;

      initialized = 1;
    }

  cob_save_call_params = cob_call_params;

  /* Entry dispatch */
  goto l_5;

  /* PROCEDURE DIVISION */

  /* 000-File-Error SECTION */

  l_2:;

  /* MAIN PARAGRAPH */


  /* 000-Handle-Error */

  /* FileStat-Msgs.cpy:12: EVALUATE */
  {
    if (((int)cob_cmp_numdisp (b_111 + 13, 2, 0) == 0))
      {
        /* FileStat-Msgs.cpy:13: MOVE */
        {
          memcpy (b_111 + 26, "SUCCESS                  ", 25);
        }
      }
    else
      if (((int)cob_cmp_numdisp (b_111 + 13, 2, 2) == 0))
        {
          /* FileStat-Msgs.cpy:14: MOVE */
          {
            memcpy (b_111 + 26, "SUCCESS DUPLICATE        ", 25);
          }
        }
      else
        if (((int)cob_cmp_numdisp (b_111 + 13, 2, 4) == 0))
          {
            /* FileStat-Msgs.cpy:15: MOVE */
            {
              memcpy (b_111 + 26, "SUCCESS INCOMPLETE       ", 25);
            }
          }
        else
          if (((int)cob_cmp_numdisp (b_111 + 13, 2, 5) == 0))
            {
              /* FileStat-Msgs.cpy:16: MOVE */
              {
                memcpy (b_111 + 26, "SUCCESS OPTIONAL         ", 25);
              }
            }
          else
            if (((int)cob_cmp_numdisp (b_111 + 13, 2, 7) == 0))
              {
                /* FileStat-Msgs.cpy:17: MOVE */
                {
                  memcpy (b_111 + 26, "SUCCESS NO UNIT          ", 25);
                }
              }
            else
              if (((int)cob_cmp_numdisp (b_111 + 13, 2, 10) == 0))
                {
                  /* FileStat-Msgs.cpy:18: MOVE */
                  {
                    memcpy (b_111 + 26, "END OF FILE              ", 25);
                  }
                }
              else
                if (((int)cob_cmp_numdisp (b_111 + 13, 2, 14) == 0))
                  {
                    /* FileStat-Msgs.cpy:19: MOVE */
                    {
                      memcpy (b_111 + 26, "OUT OF KEY RANGE         ", 25);
                    }
                  }
                else
                  if (((int)cob_cmp_numdisp (b_111 + 13, 2, 21) == 0))
                    {
                      /* FileStat-Msgs.cpy:20: MOVE */
                      {
                        memcpy (b_111 + 26, "KEY INVALID              ", 25);
                      }
                    }
                  else
                    if (((int)cob_cmp_numdisp (b_111 + 13, 2, 22) == 0))
                      {
                        /* FileStat-Msgs.cpy:21: MOVE */
                        {
                          memcpy (b_111 + 26, "KEY EXISTS               ", 25);
                        }
                      }
                    else
                      if (((int)cob_cmp_numdisp (b_111 + 13, 2, 23) == 0))
                        {
                          /* FileStat-Msgs.cpy:22: MOVE */
                          {
                            memcpy (b_111 + 26, "KEY NOT EXISTS           ", 25);
                          }
                        }
                      else
                        if (((int)cob_cmp_numdisp (b_111 + 13, 2, 30) == 0))
                          {
                            /* FileStat-Msgs.cpy:23: MOVE */
                            {
                              memcpy (b_111 + 26, "PERMANENT ERROR          ", 25);
                            }
                          }
                        else
                          if (((int)cob_cmp_numdisp (b_111 + 13, 2, 31) == 0))
                            {
                              /* FileStat-Msgs.cpy:24: MOVE */
                              {
                                memcpy (b_111 + 26, "INCONSISTENT FILENAME    ", 25);
                              }
                            }
                          else
                            if (((int)cob_cmp_numdisp (b_111 + 13, 2, 34) == 0))
                              {
                                /* FileStat-Msgs.cpy:25: MOVE */
                                {
                                  memcpy (b_111 + 26, "BOUNDARY VIOLATION       ", 25);
                                }
                              }
                            else
                              if (((int)cob_cmp_numdisp (b_111 + 13, 2, 35) == 0))
                                {
                                  /* FileStat-Msgs.cpy:26: MOVE */
                                  {
                                    memcpy (b_111 + 26, "FILE NOT FOUND           ", 25);
                                  }
                                }
                              else
                                if (((int)cob_cmp_numdisp (b_111 + 13, 2, 37) == 0))
                                  {
                                    /* FileStat-Msgs.cpy:27: MOVE */
                                    {
                                      memcpy (b_111 + 26, "PERMISSION DENIED        ", 25);
                                    }
                                  }
                                else
                                  if (((int)cob_cmp_numdisp (b_111 + 13, 2, 38) == 0))
                                    {
                                      /* FileStat-Msgs.cpy:28: MOVE */
                                      {
                                        memcpy (b_111 + 26, "CLOSED WITH LOCK         ", 25);
                                      }
                                    }
                                  else
                                    if (((int)cob_cmp_numdisp (b_111 + 13, 2, 39) == 0))
                                      {
                                        /* FileStat-Msgs.cpy:29: MOVE */
                                        {
                                          memcpy (b_111 + 26, "CONFLICT ATTRIBUTE       ", 25);
                                        }
                                      }
                                    else
                                      if (((int)cob_cmp_numdisp (b_111 + 13, 2, 41) == 0))
                                        {
                                          /* FileStat-Msgs.cpy:30: MOVE */
                                          {
                                            memcpy (b_111 + 26, "ALREADY OPEN             ", 25);
                                          }
                                        }
                                      else
                                        if (((int)cob_cmp_numdisp (b_111 + 13, 2, 42) == 0))
                                          {
                                            /* FileStat-Msgs.cpy:31: MOVE */
                                            {
                                              memcpy (b_111 + 26, "NOT OPEN                 ", 25);
                                            }
                                          }
                                        else
                                          if (((int)cob_cmp_numdisp (b_111 + 13, 2, 43) == 0))
                                            {
                                              /* FileStat-Msgs.cpy:32: MOVE */
                                              {
                                                memcpy (b_111 + 26, "READ NOT DONE            ", 25);
                                              }
                                            }
                                          else
                                            if (((int)cob_cmp_numdisp (b_111 + 13, 2, 44) == 0))
                                              {
                                                /* FileStat-Msgs.cpy:33: MOVE */
                                                {
                                                  memcpy (b_111 + 26, "RECORD OVERFLOW          ", 25);
                                                }
                                              }
                                            else
                                              if (((int)cob_cmp_numdisp (b_111 + 13, 2, 46) == 0))
                                                {
                                                  /* FileStat-Msgs.cpy:34: MOVE */
                                                  {
                                                    memcpy (b_111 + 26, "READ ERROR               ", 25);
                                                  }
                                                }
                                              else
                                                if (((int)cob_cmp_numdisp (b_111 + 13, 2, 47) == 0))
                                                  {
                                                    /* FileStat-Msgs.cpy:35: MOVE */
                                                    {
                                                      memcpy (b_111 + 26, "INPUT DENIED             ", 25);
                                                    }
                                                  }
                                                else
                                                  if (((int)cob_cmp_numdisp (b_111 + 13, 2, 48) == 0))
                                                    {
                                                      /* FileStat-Msgs.cpy:36: MOVE */
                                                      {
                                                        memcpy (b_111 + 26, "OUTPUT DENIED            ", 25);
                                                      }
                                                    }
                                                  else
                                                    if (((int)cob_cmp_numdisp (b_111 + 13, 2, 49) == 0))
                                                      {
                                                        /* FileStat-Msgs.cpy:37: MOVE */
                                                        {
                                                          memcpy (b_111 + 26, "I/O DENIED               ", 25);
                                                        }
                                                      }
                                                    else
                                                      if (((int)cob_cmp_numdisp (b_111 + 13, 2, 51) == 0))
                                                        {
                                                          /* FileStat-Msgs.cpy:38: MOVE */
                                                          {
                                                            memcpy (b_111 + 26, "RECORD LOCKED            ", 25);
                                                          }
                                                        }
                                                      else
                                                        if (((int)cob_cmp_numdisp (b_111 + 13, 2, 52) == 0))
                                                          {
                                                            /* FileStat-Msgs.cpy:39: MOVE */
                                                            {
                                                              memcpy (b_111 + 26, "END-OF-PAGE              ", 25);
                                                            }
                                                          }
                                                        else
                                                          if (((int)cob_cmp_numdisp (b_111 + 13, 2, 57) == 0))
                                                            {
                                                              /* FileStat-Msgs.cpy:40: MOVE */
                                                              {
                                                                memcpy (b_111 + 26, "I/O LINAGE               ", 25);
                                                              }
                                                            }
                                                          else
                                                            if (((int)cob_cmp_numdisp (b_111 + 13, 2, 61) == 0))
                                                              {
                                                                /* FileStat-Msgs.cpy:41: MOVE */
                                                                {
                                                                  memcpy (b_111 + 26, "FILE SHARING FAILURE     ", 25);
                                                                }
                                                              }
                                                            else
                                                              if (((int)cob_cmp_numdisp (b_111 + 13, 2, 91) == 0))
                                                                {
                                                                  /* FileStat-Msgs.cpy:42: MOVE */
                                                                  {
                                                                    memcpy (b_111 + 26, "FILE NOT AVAILABLE       ", 25);
                                                                  }
                                                                }
  }
  /* OCic.cbl:546: MOVE */
  {
    memset (b_155, 32, 80);
  }
  /* OCic.cbl:547: IF */
  {
    if (((int)cob_cmp_numdisp (b_111 + 13, 2, 35) == 0))
      {
        /* OCic.cbl:548: DISPLAY */
        {
          cob_display (0, 1, 3, &c_90, cob_intr_trim (0, 0, &f_109, 2), &c_91);
        }
      }
    else
      {
        /* OCic.cbl:554: DISPLAY */
        {
          cob_display (0, 1, 3, &c_92, cob_intr_trim (0, 0, &f_109, 2), &c_91);
        }
      }
  }
  /* OCic.cbl:560: GOBACK */
  {
    goto exit_program;
  }

  if (frame_ptr->perform_through == 2)
    goto *frame_ptr->return_address;

  /* Entry OCic */

  l_5:;

  /* 000-Main SECTION */

  /* MAIN PARAGRAPH */

  /* OCic.cbl:566: PERFORM */
  {
    /* PERFORM 100-Initialization */
    frame_ptr++;
    frame_ptr->perform_through = 32;
    frame_ptr->return_address = &&l_133;
    goto l_32;
    l_133:
    frame_ptr--;
  }
  /* OCic.cbl:567: SET */
  {
    *(b_116 + 1) = 78;
  }
  /* OCic.cbl:568: PERFORM */
  {
    while (1)
      {
        if (((int)(int)(*(b_116 + 1) - 89) == 0))
          break;
        {
          /* OCic.cbl:569: PERFORM */
          {
            /* PERFORM 200-Let-User-Set-Switches */
            frame_ptr++;
            frame_ptr->perform_through = 41;
            frame_ptr->return_address = &&l_134;
            goto l_41;
            l_134:
            frame_ptr--;
          }
          /* OCic.cbl:570: PERFORM */
          {
            /* PERFORM 210-Run-Compiler */
            frame_ptr++;
            frame_ptr->perform_through = 45;
            frame_ptr->return_address = &&l_135;
            goto l_45;
            l_135:
            frame_ptr--;
          }
          /* OCic.cbl:571: IF */
          {
            if (((((int)(int)(*(b_116) - 89) == 0) || ((int)(int)(*(b_116) - 87) == 0)) && (((int)(int)(*(b_182 + 159) - ' ') != 0) || ((int)(int)(*(b_182 + 160) - ' ') != 0))))
              {
                /* OCic.cbl:573: PERFORM */
                {
                  /* PERFORM 220-Make-Listing */
                  frame_ptr++;
                  frame_ptr->perform_through = 51;
                  frame_ptr->return_address = &&l_136;
                  goto l_51;
                  l_136:
                  frame_ptr--;
                }
              }
          }
          /* OCic.cbl:575: IF */
          {
            if ((((int)(int)(*(b_182 + 161) - ' ') != 0) && ((int)(int)(*(b_116 + 5) - 78) == 0)))
              {
                /* OCic.cbl:577: PERFORM */
                {
                  /* PERFORM 230-Run-Program */
                  frame_ptr++;
                  frame_ptr->perform_through = 54;
                  frame_ptr->return_address = &&l_137;
                  goto l_54;
                  l_137:
                  frame_ptr--;
                }
              }
          }
        }
      }
  }

  /* 009-Done */

  /* OCic.cbl:583: PERFORM */
  {
    /* PERFORM 900-Terminate */
    frame_ptr++;
    frame_ptr->perform_through = 58;
    frame_ptr->return_address = &&l_138;
    goto l_58;
    l_138:
    frame_ptr--;
  }

  /* 010-Parse-Args SECTION */

  l_9:;

  /* 011-Init */

  /* OCic.cbl:674: MOVE */
  {
    (*(int *)(b_144)) = 1;
  }

  /* 012-Extract-Kwd-And-Value */

  /* OCic.cbl:678: PERFORM */
  {
    while (1)
      {
        if (((int)cob_cmp_s32_binary (b_144, 256) >= 0))
          break;
        {
          /* OCic.cbl:679: MOVE */
          {
            memcpy (b_145, b_144, 4);
          }
          /* OCic.cbl:680: UNSTRING */
          {
            cob_unstring_init (&f_96, &f_144, 1);
            cob_unstring_delimited (&cob_space, 1);
            cob_unstring_into (&f_176, 0, 0);
            cob_unstring_finish ();
          }
          /* OCic.cbl:685: IF */
          {
            if (((int)cob_cmp (&f_176, &cob_space) != 0))
              {
                /* OCic.cbl:686: UNSTRING */
                {
                  cob_unstring_init (&f_176, 0, 1);
                  cob_unstring_delimited (&c_93, 0);
                  cob_unstring_into (&f_166, 0, 0);
                  cob_unstring_into (&f_177, 0, 0);
                  cob_unstring_finish ();
                }
                /* OCic.cbl:690: PERFORM */
                {
                  /* PERFORM 030-Process-Keyword */
                  frame_ptr++;
                  frame_ptr->perform_through = 15;
                  frame_ptr->return_address = &&l_139;
                  goto l_15;
                  l_139:
                  frame_ptr--;
                }
              }
          }
        }
      }
  }

  /* 019-Done */

  /* OCic.cbl:696: EXIT */

  /* 021-Build-And-Issue-Command */

  /* OCic.cbl:706: DISPLAY */
  {
    cob_display (0, 1, 1, &f_155);
  }

  /* 029-Done */

  /* OCic.cbl:712: EXIT */

  if (frame_ptr->perform_through == 9)
    goto *frame_ptr->return_address;

  /* 030-Process-Keyword SECTION */

  l_15:;

  /* 031-Init */

  /* OCic.cbl:720: MOVE */
  {
    cob_move (cob_intr_upper_case (0, 0, &f_166), &f_166);
  }
  /* OCic.cbl:721: SET */
  {
    *(b_116 + 7) = 78;
  }

  /* 032-Process */

  /* OCic.cbl:725: EVALUATE */
  {
    if ((((int)cob_cmp (&f_166, &c_94) == 0) || ((int)cob_cmp (&f_166, &c_95) == 0)))
      {
        /* OCic.cbl:727: MOVE */
        {
          memcpy (b_144, b_145, 4);
        }
        /* OCic.cbl:728: UNSTRING */
        {
          cob_unstring_init (&f_96, &f_144, 1);
          cob_unstring_delimited (&c_93, 0);
          cob_unstring_into (&f_107, 0, 0);
          cob_unstring_into (&f_192, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:732: MOVE */
        {
          (*(int *)(b_144)) = 256;
        }
      }
    else
      if ((((int)cob_cmp (&f_166, &c_96) == 0) || ((int)cob_cmp (&f_166, &c_97) == 0)))
        {
          /* OCic.cbl:734: MOVE */
          {
            memcpy (b_166, "CONFIG      ", 12);
          }
          /* OCic.cbl:735: MOVE */
          {
            cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
          }
          /* OCic.cbl:737: EVALUATE */
          {
            if (((int)cob_cmp (&f_177, &c_98) == 0))
              {
                /* OCic.cbl:739: MOVE */
                {
                  memset (b_182 + 75, 32, 7);
                }
                /* OCic.cbl:740: MOVE */
                {
                  *(b_182 + 75) = 62;
                }
              }
            else
              if (((int)cob_cmp (&f_177, &c_99) == 0))
                {
                  /* OCic.cbl:742: MOVE */
                  {
                    memset (b_182 + 75, 32, 7);
                  }
                  /* OCic.cbl:743: MOVE */
                  {
                    *(b_182 + 76) = 62;
                  }
                }
              else
                if (((int)cob_cmp (&f_177, &c_100) == 0))
                  {
                    /* OCic.cbl:745: MOVE */
                    {
                      memset (b_182 + 75, 32, 7);
                    }
                    /* OCic.cbl:746: MOVE */
                    {
                      *(b_182 + 77) = 62;
                    }
                  }
                else
                  if (((int)cob_cmp (&f_177, &c_101) == 0))
                    {
                      /* OCic.cbl:748: MOVE */
                      {
                        memset (b_182 + 75, 32, 7);
                      }
                      /* OCic.cbl:749: MOVE */
                      {
                        *(b_182 + 78) = 62;
                      }
                    }
                  else
                    if (((int)cob_cmp (&f_177, &c_102) == 0))
                      {
                        /* OCic.cbl:751: MOVE */
                        {
                          memset (b_182 + 75, 32, 7);
                        }
                        /* OCic.cbl:752: MOVE */
                        {
                          *(b_182 + 79) = 62;
                        }
                      }
                    else
                      if (((int)cob_cmp (&f_177, &c_103) == 0))
                        {
                          /* OCic.cbl:754: MOVE */
                          {
                            memset (b_182 + 75, 32, 7);
                          }
                          /* OCic.cbl:755: MOVE */
                          {
                            *(b_182 + 80) = 62;
                          }
                        }
                      else
                        if (((int)cob_cmp (&f_177, &c_104) == 0))
                          {
                            /* OCic.cbl:757: MOVE */
                            {
                              memset (b_182 + 75, 32, 7);
                            }
                            /* OCic.cbl:758: MOVE */
                            {
                              *(b_182 + 81) = 62;
                            }
                          }
                        else
                          {
                            /* OCic.cbl:760: MOVE */
                            {
                              memcpy (b_155, "An invalid /CONFIG switch value was specified on the command line - ignored     ", 80);
                            }
                          }
          }
        }
      else
        if ((((int)cob_cmp (&f_166, &c_105) == 0) || ((int)cob_cmp (&f_166, &c_106) == 0)))
          {
            /* OCic.cbl:766: MOVE */
            {
              memcpy (b_166, "DEBUG       ", 12);
            }
            /* OCic.cbl:767: MOVE */
            {
              cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
            }
            /* OCic.cbl:769: PERFORM */
            {
              /* PERFORM 040-Process-Yes-No-Value */
              frame_ptr++;
              frame_ptr->perform_through = 19;
              frame_ptr->return_address = &&l_140;
              goto l_19;
              l_140:
              frame_ptr--;
            }
            /* OCic.cbl:770: IF */
            {
              if (((int)(int)(*(b_116 + 7) - 78) == 0))
                {
                  /* OCic.cbl:771: MOVE */
                  {
                    *(b_182 + 157) = *(b_177);
                  }
                }
            }
          }
        else
          if (((int)cob_cmp (&f_166, &c_107) == 0))
            {
              /* OCic.cbl:774: MOVE */
              {
                memcpy (b_166, "DLL         ", 12);
              }
              /* OCic.cbl:775: MOVE */
              {
                cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
              }
              /* OCic.cbl:777: PERFORM */
              {
                /* PERFORM 040-Process-Yes-No-Value */
                frame_ptr++;
                frame_ptr->perform_through = 19;
                frame_ptr->return_address = &&l_141;
                goto l_19;
                l_141:
                frame_ptr--;
              }
              /* OCic.cbl:778: IF */
              {
                if (((int)(int)(*(b_116 + 7) - 78) == 0))
                  {
                    /* OCic.cbl:779: MOVE */
                    {
                      *(b_182 + 158) = *(b_177);
                    }
                  }
              }
            }
          else
            if ((((int)cob_cmp (&f_166, &c_108) == 0) || ((int)cob_cmp (&f_166, &c_109) == 0)))
              {
                /* OCic.cbl:782: MOVE */
                {
                  memcpy (b_166, "EXECUTE     ", 12);
                }
                /* OCic.cbl:783: MOVE */
                {
                  cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
                }
                /* OCic.cbl:785: PERFORM */
                {
                  /* PERFORM 040-Process-Yes-No-Value */
                  frame_ptr++;
                  frame_ptr->perform_through = 19;
                  frame_ptr->return_address = &&l_142;
                  goto l_19;
                  l_142:
                  frame_ptr--;
                }
                /* OCic.cbl:786: IF */
                {
                  if (((int)(int)(*(b_116 + 7) - 78) == 0))
                    {
                      /* OCic.cbl:787: MOVE */
                      {
                        *(b_182 + 161) = *(b_177);
                      }
                    }
                }
              }
            else
              if ((((int)cob_cmp (&f_166, &c_110) == 0) || ((int)cob_cmp (&f_166, &c_111) == 0)))
                {
                  /* OCic.cbl:790: MOVE */
                  {
                    memcpy (b_166, "NOTRUNC     ", 12);
                  }
                  /* OCic.cbl:791: MOVE */
                  {
                    cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
                  }
                  /* OCic.cbl:793: PERFORM */
                  {
                    /* PERFORM 040-Process-Yes-No-Value */
                    frame_ptr++;
                    frame_ptr->perform_through = 19;
                    frame_ptr->return_address = &&l_143;
                    goto l_19;
                    l_143:
                    frame_ptr--;
                  }
                  /* OCic.cbl:794: IF */
                  {
                    if (((int)(int)(*(b_116 + 7) - 78) == 0))
                      {
                        /* OCic.cbl:795: MOVE */
                        {
                          *(b_182 + 162) = *(b_177);
                        }
                      }
                  }
                }
              else
                if ((((int)cob_cmp (&f_166, &c_112) == 0) || ((int)cob_cmp (&f_166, &c_113) == 0)))
                  {
                    /* OCic.cbl:798: MOVE */
                    {
                      memcpy (b_166, "SOURCE      ", 12);
                    }
                    /* OCic.cbl:799: MOVE */
                    {
                      cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
                    }
                    /* OCic.cbl:801: PERFORM */
                    {
                      /* PERFORM 050-Process-Yes-No-All */
                      frame_ptr++;
                      frame_ptr->perform_through = 22;
                      frame_ptr->return_address = &&l_144;
                      goto l_22;
                      l_144:
                      frame_ptr--;
                    }
                    /* OCic.cbl:802: IF */
                    {
                      if (((int)(int)(*(b_116 + 7) - 78) == 0))
                        {
                          /* OCic.cbl:803: MOVE */
                          {
                            *(b_182 + 160) = *(b_177);
                          }
                        }
                    }
                  }
                else
                  if ((((int)cob_cmp (&f_166, &c_114) == 0) || ((int)cob_cmp (&f_166, &c_115) == 0)))
                    {
                      /* OCic.cbl:806: MOVE */
                      {
                        memcpy (b_166, "TRACE       ", 12);
                      }
                      /* OCic.cbl:807: MOVE */
                      {
                        cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
                      }
                      /* OCic.cbl:809: PERFORM */
                      {
                        /* PERFORM 050-Process-Yes-No-All */
                        frame_ptr++;
                        frame_ptr->perform_through = 22;
                        frame_ptr->return_address = &&l_145;
                        goto l_22;
                        l_145:
                        frame_ptr--;
                      }
                      /* OCic.cbl:810: IF */
                      {
                        if (((int)(int)(*(b_116 + 7) - 78) == 0))
                          {
                            /* OCic.cbl:811: MOVE */
                            {
                              *(b_182 + 164) = *(b_177);
                            }
                          }
                      }
                    }
                  else
                    if ((((int)cob_cmp (&f_166, &c_116) == 0) || ((int)cob_cmp (&f_166, &c_117) == 0)))
                      {
                        /* OCic.cbl:814: MOVE */
                        {
                          memcpy (b_166, "XREF        ", 12);
                        }
                        /* OCic.cbl:815: MOVE */
                        {
                          cob_move (cob_intr_upper_case (0, 0, &f_177), &f_177);
                        }
                        /* OCic.cbl:817: PERFORM */
                        {
                          /* PERFORM 050-Process-Yes-No-All */
                          frame_ptr++;
                          frame_ptr->perform_through = 22;
                          frame_ptr->return_address = &&l_146;
                          goto l_22;
                          l_146:
                          frame_ptr--;
                        }
                        /* OCic.cbl:818: IF */
                        {
                          if (((int)(int)(*(b_116 + 7) - 78) == 0))
                            {
                              /* OCic.cbl:819: MOVE */
                              {
                                *(b_182 + 159) = *(b_177);
                              }
                            }
                        }
                      }
                    else
                      {
                        /* OCic.cbl:822: MOVE */
                        {
                          memset (b_155, 32, 80);
                        }
                        /* OCic.cbl:823: STRING */
                        {
                          cob_string_init (&f_155, 0);
                          cob_string_delimited (0);
                          cob_string_append (&c_91);
                          cob_string_append (cob_intr_trim (0, 0, &f_166, 0));
                          cob_string_append (&c_118);
                          cob_string_finish ();
                        }
                        /* OCic.cbl:830: SET */
                        {
                          *(b_116 + 7) = 89;
                        }
                      }
  }

  /* 039-Done */

  /* OCic.cbl:835: EXIT */

  if (frame_ptr->perform_through == 15)
    goto *frame_ptr->return_address;

  /* 040-Process-Yes-No-Value SECTION */

  l_19:;

  /* 042-Process */

  /* OCic.cbl:843: EVALUATE */
  {
    if (((int)(int)(*(b_177) - 89) == 0))
      {
        /* OCic.cbl:845: MOVE */
        {
          cob_move (&c_119, &f_177);
        }
      }
    else
      if (((int)(int)(*(b_177) - 78) == 0))
        {
          /* OCic.cbl:847: MOVE */
          {
            cob_move (&c_120, &f_177);
          }
        }
      else
        {
          /* OCic.cbl:849: MOVE */
          {
            memset (b_155, 32, 80);
          }
          /* OCic.cbl:850: STRING */
          {
            cob_string_init (&f_155, 0);
            cob_string_delimited (&cob_space);
            cob_string_append (&c_121);
            cob_string_append (cob_intr_trim (0, 0, &f_177, 0));
            cob_string_append (&c_122);
            cob_string_append (cob_intr_trim (0, 0, &f_166, 0));
            cob_string_append (&c_123);
            cob_string_finish ();
          }
          /* OCic.cbl:856: SET */
          {
            *(b_116 + 7) = 89;
          }
        }
  }

  /* 049-Done */

  /* OCic.cbl:861: EXIT */

  if (frame_ptr->perform_through == 19)
    goto *frame_ptr->return_address;

  /* 050-Process-Yes-No-All SECTION */

  l_22:;

  /* 052-Process */

  /* OCic.cbl:869: IF */
  {
    if (((int)(int)(*(b_177) - 65) == 0))
      {
        /* OCic.cbl:870: MOVE */
        {
          cob_move (&c_124, &f_177);
        }
      }
    else
      {
        /* OCic.cbl:872: PERFORM */
        {
          /* PERFORM 040-Process-Yes-No-Value */
          frame_ptr++;
          frame_ptr->perform_through = 19;
          frame_ptr->return_address = &&l_147;
          goto l_19;
          l_147:
          frame_ptr--;
        }
      }
  }

  /* 059-Done */

  /* OCic.cbl:877: EXIT */

  if (frame_ptr->perform_through == 22)
    goto *frame_ptr->return_address;

  /* 060-Process-Yes-No-Auto SECTION */

  /* 061-Init */

  /* OCic.cbl:885: IF */
  {
    if (((int)(int)(*(b_177) - 65) == 0))
      {
        /* OCic.cbl:886: PERFORM */
        {
          /* PERFORM 070-Find-LINKAGE-SECTION */
          frame_ptr++;
          frame_ptr->perform_through = 27;
          frame_ptr->return_address = &&l_148;
          goto l_27;
          l_148:
          frame_ptr--;
        }
        /* OCic.cbl:887: IF */
        {
          if (((int)(int)(*(b_116 + 3) - 89) == 0))
            {
              /* OCic.cbl:888: MOVE */
              {
                cob_move (&c_125, &f_177);
              }
            }
          else
            {
              /* OCic.cbl:890: MOVE */
              {
                cob_move (&c_126, &f_177);
              }
            }
        }
      }
    else
      {
        /* OCic.cbl:893: PERFORM */
        {
          /* PERFORM 040-Process-Yes-No-Value */
          frame_ptr++;
          frame_ptr->perform_through = 19;
          frame_ptr->return_address = &&l_149;
          goto l_19;
          l_149:
          frame_ptr--;
        }
      }
  }

  /* 070-Find-LINKAGE-SECTION SECTION */

  l_27:;

  /* 071-Init */

  /* OCic.cbl:903: OPEN */
  {
    cob_exception_code = 0;
    {
      cob_open (h_SOURCE_CODE, 1, 0, &f_113);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM 000-File-Error */
        frame_ptr++;
        frame_ptr->perform_through = 2;
        frame_ptr->return_address = &&l_150;
        goto l_2;
        l_150:
        frame_ptr--;
      }
  }
  /* OCic.cbl:904: SET */
  {
    *(b_116 + 3) = 78;
  }
  /* OCic.cbl:905: SET */
  {
    *(b_116 + 2) = 78;
  }
  /* OCic.cbl:906: PERFORM */
  {
    while (1)
      {
        if (((int)(int)(*(b_116 + 2) - 89) == 0))
          break;
        {
          /* OCic.cbl:907: READ */
          cob_exception_code = 0;
          {
            cob_read (h_SOURCE_CODE, 0, &f_113, 1);
          }
          if (unlikely(cob_exception_code != 0))
            {
              if (cob_exception_code == 0x0501)
                {
                  {
                    /* OCic.cbl:908: CLOSE */
                    {
                      cob_exception_code = 0;
                      {
                        cob_close (h_SOURCE_CODE, 0, &f_113);
                      }
                      if (unlikely(cob_exception_code != 0))
                        {
                          /* PERFORM 000-File-Error */
                          frame_ptr++;
                          frame_ptr->perform_through = 2;
                          frame_ptr->return_address = &&l_151;
                          goto l_2;
                          l_151:
                          frame_ptr--;
                        }
                    }
                    /* OCic.cbl:909: EXIT */
                    {
                      goto l_29;
                    }
                  }
                }
              else
                {
                  /* PERFORM 000-File-Error */
                  frame_ptr++;
                  frame_ptr->perform_through = 2;
                  frame_ptr->return_address = &&l_152;
                  goto l_2;
                  l_152:
                  frame_ptr--;
                }
            }
          /* OCic.cbl:911: CALL */
          {
            {

              module.cob_procedure_parameters[0] = &f_9;
              module.cob_procedure_parameters[1] = &f_136;
              module.cob_procedure_parameters[2] = NULL;
              module.cob_procedure_parameters[3] = NULL;
              module.cob_procedure_parameters[4] = NULL;
              module.cob_procedure_parameters[5] = NULL;
              cob_call_params = 2;
              if (unlikely(call_CHECKSOURCE.func_void == NULL)) {
                call_CHECKSOURCE.func_void = cob_resolve_1 ((const char *)"CHECKSOURCE");
              }
              (*(int *) (b_1)) = call_CHECKSOURCE.funcint (b_10, b_116 + 6);
            }
          }
          /* OCic.cbl:914: IF */
          {
            if (((int)(int)(*(b_116 + 6) - 73) == 0))
              {
                /* OCic.cbl:915: SET */
                {
                  *(b_116 + 2) = 89;
                }
              }
          }
        }
      }
  }

  /* 072-Process-Source */

  /* OCic.cbl:921: SET */
  {
    *(b_116 + 6) = 32;
  }
  /* OCic.cbl:922: PERFORM */
  {
    while (1)
      {
        if ((((int)(int)(*(b_116 + 6) - 76) == 0) || ((int)(int)(*(b_116 + 6) - 73) == 0)))
          break;
        {
          /* OCic.cbl:924: READ */
          cob_exception_code = 0;
          {
            cob_read (h_SOURCE_CODE, 0, &f_113, 1);
          }
          if (unlikely(cob_exception_code != 0))
            {
              if (cob_exception_code == 0x0501)
                {
                  {
                    /* OCic.cbl:925: CLOSE */
                    {
                      cob_exception_code = 0;
                      {
                        cob_close (h_SOURCE_CODE, 0, &f_113);
                      }
                      if (unlikely(cob_exception_code != 0))
                        {
                          /* PERFORM 000-File-Error */
                          frame_ptr++;
                          frame_ptr->perform_through = 2;
                          frame_ptr->return_address = &&l_153;
                          goto l_2;
                          l_153:
                          frame_ptr--;
                        }
                    }
                    /* OCic.cbl:926: EXIT */
                    {
                      goto l_29;
                    }
                  }
                }
              else
                {
                  /* PERFORM 000-File-Error */
                  frame_ptr++;
                  frame_ptr->perform_through = 2;
                  frame_ptr->return_address = &&l_154;
                  goto l_2;
                  l_154:
                  frame_ptr--;
                }
            }
          /* OCic.cbl:928: CALL */
          {
            {

              module.cob_procedure_parameters[0] = &f_9;
              module.cob_procedure_parameters[1] = &f_136;
              module.cob_procedure_parameters[2] = NULL;
              module.cob_procedure_parameters[3] = NULL;
              module.cob_procedure_parameters[4] = NULL;
              module.cob_procedure_parameters[5] = NULL;
              cob_call_params = 2;
              if (unlikely(call_CHECKSOURCE.func_void == NULL)) {
                call_CHECKSOURCE.func_void = cob_resolve_1 ((const char *)"CHECKSOURCE");
              }
              (*(int *) (b_1)) = call_CHECKSOURCE.funcint (b_10, b_116 + 6);
            }
          }
        }
      }
  }
  /* OCic.cbl:932: CLOSE */
  {
    cob_exception_code = 0;
    {
      cob_close (h_SOURCE_CODE, 0, &f_113);
    }
    if (unlikely(cob_exception_code != 0))
      {
        /* PERFORM 000-File-Error */
        frame_ptr++;
        frame_ptr->perform_through = 2;
        frame_ptr->return_address = &&l_155;
        goto l_2;
        l_155:
        frame_ptr--;
      }
  }
  /* OCic.cbl:933: IF */
  {
    if (((int)(int)(*(b_116 + 6) - 76) == 0))
      {
        /* OCic.cbl:934: SET */
        {
          *(b_116 + 3) = 89;
        }
      }
  }

  /* 079-Done */

  /* OCic.cbl:939: EXIT */

  /* EXIT SECTION 29 */

  l_29:;

  if (frame_ptr->perform_through == 27)
    goto *frame_ptr->return_address;

  /* 100-Initialization SECTION */

  l_32:;

  /* 101-Determine-OS-Type */

  /* OCic.cbl:948: CALL */
  {
    {

      module.cob_procedure_parameters[0] = NULL;
      module.cob_procedure_parameters[1] = NULL;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      cob_call_params = 0;
      if (unlikely(call_GETOSTYPE.func_void == NULL)) {
        call_GETOSTYPE.func_void = cob_resolve_1 ((const char *)"GETOSTYPE");
      }
      (*(int *) (b_1)) = call_GETOSTYPE.funcint ();
    }
  }
  /* OCic.cbl:950: MOVE */
  {
    cob_set_int (&f_149, (*(int *) (b_1)));
  }
  /* OCic.cbl:951: EVALUATE */
  {
    if (((int)cob_cmp_s32_binary (b_149, 0) == 0))
      {
        /* OCic.cbl:953: MOVE */
        {
          *(b_106) = 92;
        }
        /* OCic.cbl:954: MOVE */
        {
          memcpy (b_154, "Unknown", 7);
        }
        /* OCic.cbl:955: MOVE */
        {
          memcpy (b_98, "1011", 4);
        }
        /* OCic.cbl:956: MOVE */
        {
          memcpy (b_98 + 4, "1012", 4);
        }
        /* OCic.cbl:957: MOVE */
        {
          memcpy (b_98 + 8, "1013", 4);
        }
        /* OCic.cbl:958: MOVE */
        {
          memcpy (b_98 + 12, "1014", 4);
        }
        /* OCic.cbl:959: MOVE */
        {
          memcpy (b_98 + 16, "1015", 4);
        }
        /* OCic.cbl:960: MOVE */
        {
          memcpy (b_98 + 20, "1016", 4);
        }
        /* OCic.cbl:961: MOVE */
        {
          memcpy (b_98 + 24, "1017", 4);
        }
      }
    else
      if (((int)cob_cmp_s32_binary (b_149, 1) == 0))
        {
          /* OCic.cbl:963: MOVE */
          {
            *(b_106) = 92;
          }
          /* OCic.cbl:964: MOVE */
          {
            memcpy (b_154, "Windows", 7);
          }
          /* OCic.cbl:965: MOVE */
          {
            memcpy (b_98, "1013", 4);
          }
          /* OCic.cbl:966: MOVE */
          {
            memcpy (b_98 + 4, "1014", 4);
          }
          /* OCic.cbl:967: MOVE */
          {
            memcpy (b_98 + 8, "1015", 4);
          }
          /* OCic.cbl:968: MOVE */
          {
            memcpy (b_98 + 12, "1016", 4);
          }
          /* OCic.cbl:969: MOVE */
          {
            memcpy (b_98 + 16, "1017", 4);
          }
          /* OCic.cbl:970: MOVE */
          {
            memcpy (b_98 + 20, "1018", 4);
          }
          /* OCic.cbl:971: MOVE */
          {
            memcpy (b_98 + 24, "1019", 4);
          }
        }
      else
        if (((int)cob_cmp_s32_binary (b_149, 2) == 0))
          {
            /* OCic.cbl:973: MOVE */
            {
              *(b_106) = 47;
            }
            /* OCic.cbl:974: MOVE */
            {
              memcpy (b_154, "Cygwin ", 7);
            }
            /* OCic.cbl:975: MOVE */
            {
              memcpy (b_98, "1011", 4);
            }
            /* OCic.cbl:976: MOVE */
            {
              memcpy (b_98 + 4, "1012", 4);
            }
            /* OCic.cbl:977: MOVE */
            {
              memcpy (b_98 + 8, "1013", 4);
            }
            /* OCic.cbl:978: MOVE */
            {
              memcpy (b_98 + 12, "1014", 4);
            }
            /* OCic.cbl:979: MOVE */
            {
              memcpy (b_98 + 16, "1015", 4);
            }
            /* OCic.cbl:980: MOVE */
            {
              memcpy (b_98 + 20, "1016", 4);
            }
            /* OCic.cbl:981: MOVE */
            {
              memcpy (b_98 + 24, "1017", 4);
            }
          }
        else
          if (((int)cob_cmp_s32_binary (b_149, 3) == 0))
            {
              /* OCic.cbl:983: MOVE */
              {
                *(b_106) = 47;
              }
              /* OCic.cbl:984: MOVE */
              {
                memcpy (b_154, "UNIX   ", 7);
              }
              /* OCic.cbl:985: MOVE */
              {
                memcpy (b_98, "1011", 4);
              }
              /* OCic.cbl:986: MOVE */
              {
                memcpy (b_98 + 4, "1012", 4);
              }
              /* OCic.cbl:987: MOVE */
              {
                memcpy (b_98 + 8, "1013", 4);
              }
              /* OCic.cbl:988: MOVE */
              {
                memcpy (b_98 + 12, "1014", 4);
              }
              /* OCic.cbl:989: MOVE */
              {
                memcpy (b_98 + 16, "1015", 4);
              }
              /* OCic.cbl:990: MOVE */
              {
                memcpy (b_98 + 20, "1016", 4);
              }
              /* OCic.cbl:991: MOVE */
              {
                memcpy (b_98 + 24, "1017", 4);
              }
            }
  }

  /* 102-Set-Environment-Vars */

  /* OCic.cbl:996: SET */
  {
    cob_set_environment (&c_127, &c_125);
  }
  /* OCic.cbl:997: SET */
  {
    cob_set_environment (&c_128, &c_125);
  }

  /* 103-Generate-Cobc-Output-Fn */

  /* OCic.cbl:1001: ACCEPT */
  {
    cob_get_environment (&c_129, &f_108);
  }
  /* OCic.cbl:1004: MOVE */
  {
    memset (b_95, 32, 256);
  }
  /* OCic.cbl:1005: STRING */
  {
    cob_string_init (&f_95, 0);
    cob_string_delimited (0);
    cob_string_append (cob_intr_trim (0, 0, &f_108, 2));
    cob_string_append (&f_106);
    cob_string_append (&c_130);
    cob_string_finish ();
  }

  /* 104-Generate-Banner-Line-Info */

  /* OCic.cbl:1014: MOVE */
  {
    cob_move (cob_intr_when_compiled (1, 12, &c_131), &f_148);
  }
  /* OCic.cbl:1015: INSPECT */
  {
    cob_inspect_init (&f_148, 1);
    cob_inspect_start ();
    cob_inspect_after (&cob_space);
    cob_inspect_all (&c_132, &c_133);
    cob_inspect_finish ();
  }

  /* 105-Establish-Switch-Settings */

  /* OCic.cbl:1021: ACCEPT */
  {
    cob_accept_command_line (&f_96);
  }
  /* OCic.cbl:1024: MOVE */
  {
    cob_move (cob_intr_trim (0, 0, &f_96, 1), &f_96);
  }
  /* OCic.cbl:1026: MOVE */
  {
    (*(int *)(b_203)) = 0;
  }
  /* OCic.cbl:1027: INSPECT */
  {
    cob_inspect_init (&f_96, 0);
    cob_inspect_start ();
    cob_inspect_all (&f_203, &c_134);
    cob_inspect_finish ();
  }
  /* OCic.cbl:1028: IF */
  {
    if (((int)cob_cmp_s32_binary (b_203, 0) == 0))
      {
        /* OCic.cbl:1029: MOVE */
        {
          memcpy (b_109, b_96, 256);
        }
        /* OCic.cbl:1030: MOVE */
        {
          memset (b_96, 32, 256);
        }
      }
    else
      {
        /* OCic.cbl:1032: UNSTRING */
        {
          cob_unstring_init (&f_96, 0, 1);
          cob_unstring_delimited (&c_134, 0);
          cob_unstring_into (&f_109, 0, 0);
          cob_unstring_into (&f_107, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:1035: INSPECT */
        {
          cob_inspect_init (&f_96, 1);
          cob_inspect_start ();
          cob_inspect_first (&cob_low, &c_134);
          cob_inspect_finish ();
        }
        /* OCic.cbl:1037: UNSTRING */
        {
          cob_unstring_init (&f_96, 0, 1);
          cob_unstring_delimited (&cob_low, 0);
          cob_unstring_into (&f_107, 0, 0);
          cob_unstring_into (&f_93, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:1041: MOVE */
        {
          memset (b_96, 32, 256);
        }
        /* OCic.cbl:1042: STRING */
        {
          cob_string_init (&f_96, 0);
          cob_string_delimited (0);
          cob_string_append (&c_134);
          cob_string_append (&f_93);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1046: IF */
  {
    if (((int)cob_cmp (&f_109, &cob_space) == 0))
      {
        /* OCic.cbl:1047: DISPLAY */
        {
          cob_display (0, 1, 1, &c_135);
        }
        /* OCic.cbl:1050: PERFORM */
        {
          /* PERFORM 900-Terminate */
          frame_ptr++;
          frame_ptr->perform_through = 58;
          frame_ptr->return_address = &&l_156;
          goto l_58;
          l_156:
          frame_ptr--;
        }
      }
  }
  /* OCic.cbl:1052: PERFORM */
  {
    /* PERFORM 010-Parse-Args */
    frame_ptr++;
    frame_ptr->perform_through = 9;
    frame_ptr->return_address = &&l_157;
    goto l_9;
    l_157:
    frame_ptr--;
  }
  /* OCic.cbl:1053: IF */
  {
    if (((int)(int)(*(b_182 + 163) - 65) == 0))
      {
        /* OCic.cbl:1054: MOVE */
        {
          memcpy (b_166, "S           ", 12);
        }
        /* OCic.cbl:1055: MOVE */
        {
          cob_move (&c_136, &f_177);
        }
        /* OCic.cbl:1056: PERFORM */
        {
          /* PERFORM 070-Find-LINKAGE-SECTION */
          frame_ptr++;
          frame_ptr->perform_through = 27;
          frame_ptr->return_address = &&l_158;
          goto l_27;
          l_158:
          frame_ptr--;
        }
        /* OCic.cbl:1057: IF */
        {
          if (((int)(int)(*(b_116 + 3) - 89) == 0))
            {
              /* OCic.cbl:1058: MOVE */
              {
                *(b_182 + 163) = 89;
              }
            }
          else
            {
              /* OCic.cbl:1060: MOVE */
              {
                *(b_182 + 163) = 78;
              }
            }
        }
      }
  }
  /* OCic.cbl:1063: INSPECT */
  {
    cob_inspect_init (&f_193, 1);
    cob_inspect_start ();
    cob_inspect_all (&c_137, &c_125);
    cob_inspect_finish ();
  }
  /* OCic.cbl:1064: INSPECT */
  {
    cob_inspect_init (&f_193, 1);
    cob_inspect_start ();
    cob_inspect_all (&c_138, &c_126);
    cob_inspect_finish ();
  }

  /* 106-Determine-Folder-Path */

  /* OCic.cbl:1068: MOVE */
  {
    (*(int *)(b_144)) = 256;
  }
  /* OCic.cbl:1069: IF */
  {
    if ((((int)cob_cmp_s32_binary (b_149, 2) == 0) && ((int)(int)(*(b_109 + 1) - 58) == 0)))
      {
        /* OCic.cbl:1070: MOVE */
        {
          *(b_106) = 92;
        }
      }
  }
  /* OCic.cbl:1072: PERFORM */
  {
    while (1)
      {
        if ((((int)cob_cmp_s32_binary (b_144, 0) == 0) || ((int)(int)(*(b_109 + ((*(int *)(b_144)) - 1)) - *(b_106)) == 0)))
          break;
        {
          /* OCic.cbl:1073: SUBTRACT */
          {
            (*(int *)(b_144)) = ((*(int *)(b_144)) - 1);
          }
        }
      }
  }
  /* OCic.cbl:1075: IF */
  {
    if (((int)cob_cmp_s32_binary (b_144, 0) == 0))
      {
        /* OCic.cbl:1076: MOVE */
        {
          memset (b_157, 32, 256);
        }
        /* OCic.cbl:1077: MOVE */
        {
          memcpy (b_159, b_109, 40);
        }
      }
    else
      {
        /* OCic.cbl:1079: MOVE */
        {
          *(b_109 + ((*(int *)(b_144)) - 1)) = 42;
        }
        /* OCic.cbl:1080: UNSTRING */
        {
          cob_unstring_init (&f_109, 0, 1);
          cob_unstring_delimited (&c_139, 0);
          cob_unstring_into (&f_157, 0, 0);
          cob_unstring_into (&f_159, 0, 0);
          cob_unstring_finish ();
        }
        /* OCic.cbl:1084: MOVE */
        {
          *(b_109 + ((*(int *)(b_144)) - 1)) = *(b_106);
        }
      }
  }
  /* OCic.cbl:1086: UNSTRING */
  {
    cob_unstring_init (&f_159, 0, 1);
    cob_unstring_delimited (&c_140, 0);
    cob_unstring_into (&f_160, 0, 0);
    cob_unstring_into (&f_158, 0, 0);
    cob_unstring_finish ();
  }
  /* OCic.cbl:1089: IF */
  {
    if (((int)cob_cmp (&f_157, &cob_space) == 0))
      {
        /* OCic.cbl:1090: ACCEPT */
        {
          cob_get_environment (&c_141, &f_157);
        }
      }
    else
      {
        /* OCic.cbl:1094: CALL */
        {
          {

            module.cob_procedure_parameters[0] = cob_intr_trim (0, 0, &f_157, 2);
            module.cob_procedure_parameters[1] = NULL;
            module.cob_procedure_parameters[2] = NULL;
            module.cob_procedure_parameters[3] = NULL;
            module.cob_procedure_parameters[4] = NULL;
            cob_call_params = 1;
            (*(int *) (b_1)) = CBL_CHANGE_DIR (module.cob_procedure_parameters[0]->data);
          }
        }
      }
  }
  /* OCic.cbl:1098: IF */
  {
    if ((((int)cob_cmp_s32_binary (b_149, 2) == 0) && ((int)(int)(*(b_109 + 1) - 58) == 0)))
      {
        /* OCic.cbl:1099: MOVE */
        {
          *(b_106) = 47;
        }
      }
  }

  /* 107-Other */

  /* OCic.cbl:1104: MOVE */
  {
    memset (b_143, 196, 80);
  }
  /* OCic.cbl:1105: MOVE */
  {
    cob_move (cob_intr_concatenate (0, 0, 4, &c_142, cob_intr_trim (0, 0, &f_154, 2), &c_143, &c_144), &f_155);
  }

  /* 109-Done */

  /* OCic.cbl:1113: EXIT */

  if (frame_ptr->perform_through == 32)
    goto *frame_ptr->return_address;

  /* 200-Let-User-Set-Switches SECTION */

  l_41:;

  /* 201-Init */

  /* OCic.cbl:1122: SET */
  {
    *(b_116 + 4) = 78;
  }

  /* 202-Show-And-Change-Switches */

  /* OCic.cbl:1126: PERFORM */
  {
    while (1)
      {
        if (((int)(int)(*(b_116 + 4) - 89) == 0))
          break;
        {
          /* OCic.cbl:1127: ACCEPT */
          {
            cob_move (&f_183, &f_351);
            cob_move (&f_192, &f_350);
            cob_move (&f_191, &f_340);
            cob_move (&f_190, &f_339);
            cob_move (&f_189, &f_338);
            cob_move (&f_188, &f_337);
            cob_move (&f_187, &f_336);
            cob_move (&f_186, &f_335);
            cob_move (&f_185, &f_334);
            cob_move (&f_196, &f_314);
            cob_move (&f_197, &f_313);
            cob_move (&f_202, &f_312);
            cob_move (&f_201, &f_311);
            cob_move (&f_199, &f_310);
            cob_move (&f_198, &f_309);
            cob_move (&f_200, &f_308);
            cob_move (&f_195, &f_307);
            cob_move (&f_194, &f_306);
            cob_move (&f_159, &f_294);
            cob_move (&f_157, &f_293);
            cob_move (&f_160, &f_292);
            cob_move (&f_155, &f_278);
            cob_move (&f_148, &f_276);
            cob_move (&f_143, &f_272);
            cob_move (&f_143, &f_267);
            cob_move (&f_143, &f_264);
            cob_move (&f_143, &f_259);
            cob_move (&f_143, &f_256);
            cob_move (&f_143, &f_254);
            cob_move (&f_143, &f_230);
            cob_move (&f_143, &f_228);
            cob_move (&f_143, &f_225);
            cob_move (&f_143, &f_216);
            cob_screen_accept (&s_213, NULL, NULL);
            cob_move (&f_351, &f_183);
            cob_move (&f_350, &f_192);
          }
          /* OCic.cbl:1130: IF */
          {
            if (((int)cob_cmp_numdisp (b_352, 4, 0) >  0))
              {
                /* OCic.cbl:1131: EVALUATE */
                {
                  if (((int)cob_cmp_numdisp (b_352, 4, 1001) == 0))
                    {
                      /* OCic.cbl:1133: IF */
                      {
                        if (((int)(int)(*(b_182 + 157) - ' ') == 0))
                          {
                            /* OCic.cbl:1134: MOVE */
                            {
                              *(b_182 + 157) = 62;
                            }
                          }
                        else
                          {
                            /* OCic.cbl:1136: MOVE */
                            {
                              *(b_182 + 157) = 32;
                            }
                          }
                      }
                    }
                  else
                    if (((int)cob_cmp_numdisp (b_352, 4, 1002) == 0))
                      {
                        /* OCic.cbl:1139: IF */
                        {
                          if (((int)(int)(*(b_182 + 158) - ' ') == 0))
                            {
                              /* OCic.cbl:1140: MOVE */
                              {
                                *(b_182 + 158) = 62;
                              }
                            }
                          else
                            {
                              /* OCic.cbl:1142: MOVE */
                              {
                                *(b_182 + 158) = 32;
                              }
                            }
                        }
                      }
                    else
                      if (((int)cob_cmp_numdisp (b_352, 4, 1003) == 0))
                        {
                          /* OCic.cbl:1145: IF */
                          {
                            if (((int)(int)(*(b_182 + 163) - ' ') == 0))
                              {
                                /* OCic.cbl:1146: MOVE */
                                {
                                  *(b_182 + 163) = 62;
                                }
                                /* OCic.cbl:1147: MOVE */
                                {
                                  *(b_182 + 161) = 32;
                                }
                              }
                            else
                              {
                                /* OCic.cbl:1149: MOVE */
                                {
                                  *(b_182 + 163) = 32;
                                }
                              }
                          }
                        }
                      else
                        if (((int)cob_cmp_numdisp (b_352, 4, 1004) == 0))
                          {
                            /* OCic.cbl:1152: IF */
                            {
                              if ((((int)(int)(*(b_182 + 161) - ' ') == 0) && ((int)(int)(*(b_182 + 163) - ' ') == 0)))
                                {
                                  /* OCic.cbl:1154: MOVE */
                                  {
                                    *(b_182 + 161) = 62;
                                  }
                                }
                              else
                                {
                                  /* OCic.cbl:1156: MOVE */
                                  {
                                    *(b_182 + 161) = 32;
                                  }
                                }
                            }
                          }
                        else
                          if (((int)cob_cmp_numdisp (b_352, 4, 1005) == 0))
                            {
                              /* OCic.cbl:1159: IF */
                              {
                                if (((int)(int)(*(b_182 + 162) - ' ') == 0))
                                  {
                                    /* OCic.cbl:1160: MOVE */
                                    {
                                      *(b_182 + 162) = 62;
                                    }
                                  }
                                else
                                  {
                                    /* OCic.cbl:1162: MOVE */
                                    {
                                      *(b_182 + 162) = 32;
                                    }
                                  }
                              }
                            }
                          else
                            if (((int)cob_cmp_numdisp (b_352, 4, 1006) == 0))
                              {
                                /* OCic.cbl:1165: IF */
                                {
                                  if (((int)(int)(*(b_182 + 164) - ' ') == 0))
                                    {
                                      /* OCic.cbl:1166: MOVE */
                                      {
                                        *(b_182 + 164) = 62;
                                      }
                                      /* OCic.cbl:1167: MOVE */
                                      {
                                        *(b_182 + 165) = 32;
                                      }
                                    }
                                  else
                                    {
                                      /* OCic.cbl:1169: MOVE */
                                      {
                                        *(b_182 + 164) = 32;
                                      }
                                    }
                                }
                              }
                            else
                              if (((int)cob_cmp_numdisp (b_352, 4, 1007) == 0))
                                {
                                  /* OCic.cbl:1172: IF */
                                  {
                                    if (((int)(int)(*(b_182 + 165) - ' ') == 0))
                                      {
                                        /* OCic.cbl:1173: MOVE */
                                        {
                                          *(b_182 + 165) = 62;
                                        }
                                        /* OCic.cbl:1174: MOVE */
                                        {
                                          *(b_182 + 164) = 32;
                                        }
                                      }
                                    else
                                      {
                                        /* OCic.cbl:1176: MOVE */
                                        {
                                          *(b_182 + 165) = 32;
                                        }
                                      }
                                  }
                                }
                              else
                                if (((int)cob_cmp_numdisp (b_352, 4, 1008) == 0))
                                  {
                                    /* OCic.cbl:1179: IF */
                                    {
                                      if (((int)(int)(*(b_182 + 160) - ' ') == 0))
                                        {
                                          /* OCic.cbl:1180: MOVE */
                                          {
                                            *(b_182 + 160) = 62;
                                          }
                                        }
                                      else
                                        {
                                          /* OCic.cbl:1182: MOVE */
                                          {
                                            *(b_182 + 160) = 32;
                                          }
                                        }
                                    }
                                  }
                                else
                                  if (((int)cob_cmp_numdisp (b_352, 4, 1009) == 0))
                                    {
                                      /* OCic.cbl:1185: IF */
                                      {
                                        if (((int)(int)(*(b_182 + 159) - ' ') == 0))
                                          {
                                            /* OCic.cbl:1186: MOVE */
                                            {
                                              *(b_182 + 159) = 62;
                                            }
                                          }
                                        else
                                          {
                                            /* OCic.cbl:1188: MOVE */
                                            {
                                              *(b_182 + 159) = 32;
                                            }
                                          }
                                      }
                                    }
                                  else
                                    if (((int)cob_cmp_numdisp (b_352, 4, 2005) == 0))
                                      {
                                        /* OCic.cbl:1191: PERFORM */
                                        {
                                          /* PERFORM 900-Terminate */
                                          frame_ptr++;
                                          frame_ptr->perform_through = 58;
                                          frame_ptr->return_address = &&l_159;
                                          goto l_58;
                                          l_159:
                                          frame_ptr--;
                                        }
                                      }
                                    else
                                      if (((int)memcmp (b_352, b_98, 4) == 0))
                                        {
                                          /* OCic.cbl:1193: MOVE */
                                          {
                                            memset (b_182 + 75, 32, 7);
                                          }
                                          /* OCic.cbl:1194: MOVE */
                                          {
                                            *(b_182 + 75) = 62;
                                          }
                                        }
                                      else
                                        if (((int)memcmp (b_352, b_98 + 4, 4) == 0))
                                          {
                                            /* OCic.cbl:1196: MOVE */
                                            {
                                              memset (b_182 + 75, 32, 7);
                                            }
                                            /* OCic.cbl:1197: MOVE */
                                            {
                                              *(b_182 + 76) = 62;
                                            }
                                          }
                                        else
                                          if (((int)memcmp (b_352, b_98 + 8, 4) == 0))
                                            {
                                              /* OCic.cbl:1199: MOVE */
                                              {
                                                memset (b_182 + 75, 32, 7);
                                              }
                                              /* OCic.cbl:1200: MOVE */
                                              {
                                                *(b_182 + 77) = 62;
                                              }
                                            }
                                          else
                                            if (((int)memcmp (b_352, b_98 + 12, 4) == 0))
                                              {
                                                /* OCic.cbl:1202: MOVE */
                                                {
                                                  memset (b_182 + 75, 32, 7);
                                                }
                                                /* OCic.cbl:1203: MOVE */
                                                {
                                                  *(b_182 + 78) = 62;
                                                }
                                              }
                                            else
                                              if (((int)memcmp (b_352, b_98 + 16, 4) == 0))
                                                {
                                                  /* OCic.cbl:1205: MOVE */
                                                  {
                                                    memset (b_182 + 75, 32, 7);
                                                  }
                                                  /* OCic.cbl:1206: MOVE */
                                                  {
                                                    *(b_182 + 79) = 62;
                                                  }
                                                }
                                              else
                                                if (((int)memcmp (b_352, b_98 + 20, 4) == 0))
                                                  {
                                                    /* OCic.cbl:1208: MOVE */
                                                    {
                                                      memset (b_182 + 75, 32, 7);
                                                    }
                                                    /* OCic.cbl:1209: MOVE */
                                                    {
                                                      *(b_182 + 80) = 62;
                                                    }
                                                  }
                                                else
                                                  if (((int)memcmp (b_352, b_98 + 24, 4) == 0))
                                                    {
                                                      /* OCic.cbl:1211: MOVE */
                                                      {
                                                        memset (b_182 + 75, 32, 7);
                                                      }
                                                      /* OCic.cbl:1212: MOVE */
                                                      {
                                                        *(b_182 + 81) = 62;
                                                      }
                                                    }
                                                  else
                                                    {
                                                      /* OCic.cbl:1214: MOVE */
                                                      {
                                                        cob_move (&c_145, &f_155);
                                                      }
                                                    }
                }
              }
            else
              {
                /* OCic.cbl:1218: SET */
                {
                  *(b_116 + 4) = 89;
                }
              }
          }
        }
      }
  }

  /* 209-Done */

  /* OCic.cbl:1224: EXIT */

  if (frame_ptr->perform_through == 41)
    goto *frame_ptr->return_address;

  /* 210-Run-Compiler SECTION */

  l_45:;

  /* 211-Init */

  /* OCic.cbl:1232: MOVE */
  {
    memset (b_93, 32, 512);
    memset (b_94, 32, 256);
    memset (b_155, 32, 80);
  }
  /* OCic.cbl:1235: DISPLAY */
  {
    cob_move (&f_183, &f_351);
    cob_move (&f_192, &f_350);
    cob_move (&f_191, &f_340);
    cob_move (&f_190, &f_339);
    cob_move (&f_189, &f_338);
    cob_move (&f_188, &f_337);
    cob_move (&f_187, &f_336);
    cob_move (&f_186, &f_335);
    cob_move (&f_185, &f_334);
    cob_move (&f_196, &f_314);
    cob_move (&f_197, &f_313);
    cob_move (&f_202, &f_312);
    cob_move (&f_201, &f_311);
    cob_move (&f_199, &f_310);
    cob_move (&f_198, &f_309);
    cob_move (&f_200, &f_308);
    cob_move (&f_195, &f_307);
    cob_move (&f_194, &f_306);
    cob_move (&f_159, &f_294);
    cob_move (&f_157, &f_293);
    cob_move (&f_160, &f_292);
    cob_move (&f_155, &f_278);
    cob_move (&f_148, &f_276);
    cob_move (&f_143, &f_272);
    cob_move (&f_143, &f_267);
    cob_move (&f_143, &f_264);
    cob_move (&f_143, &f_259);
    cob_move (&f_143, &f_256);
    cob_move (&f_143, &f_254);
    cob_move (&f_143, &f_230);
    cob_move (&f_143, &f_228);
    cob_move (&f_143, &f_225);
    cob_move (&f_143, &f_216);
    cob_screen_display (&s_213, NULL, NULL);
  }
  /* OCic.cbl:1238: MOVE */
  {
    (*(int *)(b_144)) = 1;
  }
  /* OCic.cbl:1239: EVALUATE */
  {
    if (((int)(int)(*(b_182 + 75) - ' ') != 0))
      {
        /* OCic.cbl:1241: MOVE */
        {
          memcpy (b_97, "bs2000      ", 12);
        }
      }
    else
      if (((int)(int)(*(b_182 + 76) - ' ') != 0))
        {
          /* OCic.cbl:1243: MOVE */
          {
            memcpy (b_97, "cobol85     ", 12);
          }
        }
      else
        if (((int)(int)(*(b_182 + 77) - ' ') != 0))
          {
            /* OCic.cbl:1245: MOVE */
            {
              memcpy (b_97, "cobol2002   ", 12);
            }
          }
        else
          if (((int)(int)(*(b_182 + 79) - ' ') != 0))
            {
              /* OCic.cbl:1247: MOVE */
              {
                memcpy (b_97, "ibm         ", 12);
              }
            }
          else
            if (((int)(int)(*(b_182 + 80) - ' ') != 0))
              {
                /* OCic.cbl:1249: MOVE */
                {
                  memcpy (b_97, "mf          ", 12);
                }
              }
            else
              if (((int)(int)(*(b_182 + 81) - ' ') != 0))
                {
                  /* OCic.cbl:1251: MOVE */
                  {
                    memcpy (b_97, "mvs         ", 12);
                  }
                }
              else
                {
                  /* OCic.cbl:1253: MOVE */
                  {
                    memcpy (b_97, "default     ", 12);
                  }
                }
  }

  /* 212-Build-Compile-Command */

  /* OCic.cbl:1258: MOVE */
  {
    memset (b_94, 32, 256);
  }
  /* OCic.cbl:1259: STRING */
  {
    cob_string_init (&f_94, &f_144);
    cob_string_delimited (0);
    cob_string_append (&c_146);
    cob_string_append (cob_intr_trim (0, 0, &f_97, 2));
    cob_string_append (&c_138);
    cob_string_finish ();
  }
  /* OCic.cbl:1265: IF */
  {
    if (((int)(int)(*(b_182 + 163) - 32) != 0))
      {
        /* OCic.cbl:1266: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_147);
          cob_string_finish ();
        }
      }
    else
      {
        /* OCic.cbl:1271: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_148);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1276: IF */
  {
    if (((int)(int)(*(b_182 + 157) - 32) != 0))
      {
        /* OCic.cbl:1277: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_149);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1282: IF */
  {
    if (((int)(int)(*(b_182 + 162) - 32) != 0))
      {
        /* OCic.cbl:1283: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_150);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1288: IF */
  {
    if (((int)(int)(*(b_182 + 165) - 32) != 0))
      {
        /* OCic.cbl:1289: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_151);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1294: IF */
  {
    if (((int)(int)(*(b_182 + 164) - 32) != 0))
      {
        /* OCic.cbl:1295: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_152);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1301: IF */
  {
    if (((int)cob_cmp (&f_192, &cob_space) >  0))
      {
        /* OCic.cbl:1302: STRING */
        {
          cob_string_init (&f_94, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_138);
          cob_string_append (cob_intr_trim (0, 0, &f_192, 2));
          cob_string_append (&c_138);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1309: STRING */
  {
    cob_string_init (&f_94, &f_144);
    cob_string_delimited (0);
    cob_string_append (cob_intr_trim (0, 0, &f_159, 2));
    cob_string_finish ();
  }

  /* 213-Run-Compiler */

  /* OCic.cbl:1316: MOVE */
  {
    cob_move (&c_153, &f_155);
  }
  /* OCic.cbl:1317: DISPLAY */
  {
    cob_move (&f_183, &f_351);
    cob_move (&f_192, &f_350);
    cob_move (&f_191, &f_340);
    cob_move (&f_190, &f_339);
    cob_move (&f_189, &f_338);
    cob_move (&f_188, &f_337);
    cob_move (&f_187, &f_336);
    cob_move (&f_186, &f_335);
    cob_move (&f_185, &f_334);
    cob_move (&f_196, &f_314);
    cob_move (&f_197, &f_313);
    cob_move (&f_202, &f_312);
    cob_move (&f_201, &f_311);
    cob_move (&f_199, &f_310);
    cob_move (&f_198, &f_309);
    cob_move (&f_200, &f_308);
    cob_move (&f_195, &f_307);
    cob_move (&f_194, &f_306);
    cob_move (&f_159, &f_294);
    cob_move (&f_157, &f_293);
    cob_move (&f_160, &f_292);
    cob_move (&f_155, &f_278);
    cob_move (&f_148, &f_276);
    cob_move (&f_143, &f_272);
    cob_move (&f_143, &f_267);
    cob_move (&f_143, &f_264);
    cob_move (&f_143, &f_259);
    cob_move (&f_143, &f_256);
    cob_move (&f_143, &f_254);
    cob_move (&f_143, &f_230);
    cob_move (&f_143, &f_228);
    cob_move (&f_143, &f_225);
    cob_move (&f_143, &f_216);
    cob_screen_display (&s_213, NULL, NULL);
  }
  /* OCic.cbl:1320: SET */
  {
    *(b_116 + 5) = 78;
  }
  /* OCic.cbl:1321: MOVE */
  {
    memset (b_93, 32, 512);
  }
  /* OCic.cbl:1322: STRING */
  {
    cob_string_init (&f_93, 0);
    cob_string_delimited (0);
    cob_string_append (cob_intr_trim (0, 0, &f_94, 2));
    cob_string_append (&c_154);
    cob_string_append (cob_intr_trim (0, 0, &f_95, 2));
    cob_string_finish ();
  }
  /* OCic.cbl:1328: CALL */
  {
    {

      module.cob_procedure_parameters[0] = cob_intr_trim (0, 0, &f_93, 2);
      module.cob_procedure_parameters[1] = NULL;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      cob_call_params = 1;
      (*(int *) (b_1)) = SYSTEM (module.cob_procedure_parameters[0]->data);
    }
  }
  /* OCic.cbl:1331: IF */
  {
    if (((int)((*(int *) (b_1)) - 0) == 0))
      {
        /* OCic.cbl:1332: SET */
        {
          *(b_116) = 89;
        }
      }
    else
      {
        /* OCic.cbl:1334: SET */
        {
          *(b_116) = 78;
        }
      }
  }
  /* OCic.cbl:1336: IF */
  {
    if (((int)(int)(*(b_116) - 89) == 0))
      {
        /* OCic.cbl:1337: OPEN */
        {
          cob_exception_code = 0;
          {
            cob_open (h_COBC_OUTPUT, 1, 0, NULL);
          }
          if (unlikely(cob_exception_code != 0))
            {
              /* PERFORM Default Error Handler */
              frame_ptr++;
              frame_ptr->perform_through = 1;
              frame_ptr->return_address = &&l_160;
              goto l_1;
              l_160:
              frame_ptr--;
            }
        }
        /* OCic.cbl:1338: READ */
        cob_exception_code = 0;
        {
          cob_read (h_COBC_OUTPUT, 0, NULL, 1);
        }
        if (unlikely(cob_exception_code != 0))
          {
            if (cob_exception_code == 0x0501)
              {
                {
                  /* OCic.cbl:1340: CONTINUE */
                  {
                    ;
                  }
                }
              }
            else
              {
                /* PERFORM Default Error Handler */
                frame_ptr++;
                frame_ptr->perform_through = 1;
                frame_ptr->return_address = &&l_161;
                goto l_1;
                l_161:
                frame_ptr--;
              }
          }
        else
          {
            {
              /* OCic.cbl:1342: SET */
              {
                *(b_116) = 87;
              }
            }
          }
        /* OCic.cbl:1344: CLOSE */
        {
          cob_exception_code = 0;
          {
            cob_close (h_COBC_OUTPUT, 0, NULL);
          }
          if (unlikely(cob_exception_code != 0))
            {
              /* PERFORM Default Error Handler */
              frame_ptr++;
              frame_ptr->perform_through = 1;
              frame_ptr->return_address = &&l_162;
              goto l_1;
              l_162:
              frame_ptr--;
            }
        }
      }
  }
  /* OCic.cbl:1346: MOVE */
  {
    memset (b_155, 32, 80);
  }
  /* OCic.cbl:1347: IF */
  {
    if (((int)(int)(*(b_116) - 89) == 0))
      {
        /* OCic.cbl:1348: MOVE */
        {
          cob_move (&c_155, &f_155);
        }
        /* OCic.cbl:1349: DISPLAY */
        {
          cob_move (&f_183, &f_351);
          cob_move (&f_192, &f_350);
          cob_move (&f_191, &f_340);
          cob_move (&f_190, &f_339);
          cob_move (&f_189, &f_338);
          cob_move (&f_188, &f_337);
          cob_move (&f_187, &f_336);
          cob_move (&f_186, &f_335);
          cob_move (&f_185, &f_334);
          cob_move (&f_196, &f_314);
          cob_move (&f_197, &f_313);
          cob_move (&f_202, &f_312);
          cob_move (&f_201, &f_311);
          cob_move (&f_199, &f_310);
          cob_move (&f_198, &f_309);
          cob_move (&f_200, &f_308);
          cob_move (&f_195, &f_307);
          cob_move (&f_194, &f_306);
          cob_move (&f_159, &f_294);
          cob_move (&f_157, &f_293);
          cob_move (&f_160, &f_292);
          cob_move (&f_155, &f_278);
          cob_move (&f_148, &f_276);
          cob_move (&f_143, &f_272);
          cob_move (&f_143, &f_267);
          cob_move (&f_143, &f_264);
          cob_move (&f_143, &f_259);
          cob_move (&f_143, &f_256);
          cob_move (&f_143, &f_254);
          cob_move (&f_143, &f_230);
          cob_move (&f_143, &f_228);
          cob_move (&f_143, &f_225);
          cob_move (&f_143, &f_216);
          cob_screen_display (&s_213, NULL, NULL);
        }
        /* OCic.cbl:1352: CALL */
        {
          {
            union {
                unsigned char data[8];
                long long     datall;
                int           dataint;
            } content_1;

            content_1.dataint = 2;
            module.cob_procedure_parameters[0] = &c_156;
            module.cob_procedure_parameters[1] = NULL;
            module.cob_procedure_parameters[2] = NULL;
            module.cob_procedure_parameters[3] = NULL;
            module.cob_procedure_parameters[4] = NULL;
            cob_call_params = 1;
            (*(int *) (b_1)) = cob_acuw_sleep (content_1.data);
          }
        }
        /* OCic.cbl:1355: MOVE */
        {
          memset (b_155, 32, 80);
        }
        /* OCic.cbl:1356: SET */
        {
          *(b_116 + 1) = 89;
        }
      }
    else
      {
        /* OCic.cbl:1358: DISPLAY */
        {
          cob_screen_display (&s_212, NULL, NULL);
        }
        /* OCic.cbl:1361: IF */
        {
          if (((int)(int)(*(b_116) - 87) == 0))
            {
              /* OCic.cbl:1362: DISPLAY */
              {
                cob_display (0, 1, 1, &c_157);
              }
            }
          else
            {
              /* OCic.cbl:1368: DISPLAY */
              {
                cob_display (0, 1, 1, &c_158);
              }
            }
        }
        /* OCic.cbl:1373: SET */
        {
          *(b_116) = 78;
        }
        /* OCic.cbl:1374: SET */
        {
          *(b_116 + 1) = 89;
        }
        /* OCic.cbl:1375: DISPLAY */
        {
          cob_display (0, 1, 1, &c_138);
        }
        /* OCic.cbl:1379: OPEN */
        {
          cob_exception_code = 0;
          {
            cob_open (h_COBC_OUTPUT, 1, 0, NULL);
          }
          if (unlikely(cob_exception_code != 0))
            {
              /* PERFORM Default Error Handler */
              frame_ptr++;
              frame_ptr->perform_through = 1;
              frame_ptr->return_address = &&l_163;
              goto l_1;
              l_163:
              frame_ptr--;
            }
        }
        /* OCic.cbl:1380: PERFORM */
        {
          while (1)
            {
              {
                /* OCic.cbl:1381: READ */
                cob_exception_code = 0;
                {
                  cob_read (h_COBC_OUTPUT, 0, NULL, 1);
                }
                if (unlikely(cob_exception_code != 0))
                  {
                    if (cob_exception_code == 0x0501)
                      {
                        {
                          /* OCic.cbl:1382: EXIT */
                          {
                            goto l_49;
                          }
                        }
                      }
                    else
                      {
                        /* PERFORM Default Error Handler */
                        frame_ptr++;
                        frame_ptr->perform_through = 1;
                        frame_ptr->return_address = &&l_164;
                        goto l_1;
                        l_164:
                        frame_ptr--;
                      }
                  }
                /* OCic.cbl:1384: DISPLAY */
                {
                  cob_display (0, 1, 1, cob_intr_trim (0, 0, &f_7, 2));
                }
              }
            }

          /* EXIT PERFORM 49 */

          l_49:;
        }
        /* OCic.cbl:1389: CLOSE */
        {
          cob_exception_code = 0;
          {
            cob_close (h_COBC_OUTPUT, 0, NULL);
          }
          if (unlikely(cob_exception_code != 0))
            {
              /* PERFORM Default Error Handler */
              frame_ptr++;
              frame_ptr->perform_through = 1;
              frame_ptr->return_address = &&l_165;
              goto l_1;
              l_165:
              frame_ptr--;
            }
        }
        /* OCic.cbl:1390: DISPLAY */
        {
          cob_display (0, 1, 1, &c_138);
        }
        /* OCic.cbl:1394: DISPLAY */
        {
          cob_display (0, 1, 1, &c_159);
        }
        /* OCic.cbl:1398: ACCEPT */
        {
          cob_accept (&f_107);
        }
        /* OCic.cbl:1401: DISPLAY */
        {
          cob_screen_display (&s_212, NULL, NULL);
        }
      }
  }

  /* 219-Done */

  /* OCic.cbl:1408: IF */
  {
    if (((int)(int)(*(b_116) - 78) == 0))
      {
        /* OCic.cbl:1409: PERFORM */
        {
          /* PERFORM 900-Terminate */
          frame_ptr++;
          frame_ptr->perform_through = 58;
          frame_ptr->return_address = &&l_166;
          goto l_58;
          l_166:
          frame_ptr--;
        }
      }
  }

  if (frame_ptr->perform_through == 45)
    goto *frame_ptr->return_address;

  /* 220-Make-Listing SECTION */

  l_51:;

  /* 221-Init */

  /* OCic.cbl:1419: MOVE */
  {
    cob_move (&c_160, &f_155);
  }
  /* OCic.cbl:1421: DISPLAY */
  {
    cob_move (&f_183, &f_351);
    cob_move (&f_192, &f_350);
    cob_move (&f_191, &f_340);
    cob_move (&f_190, &f_339);
    cob_move (&f_189, &f_338);
    cob_move (&f_188, &f_337);
    cob_move (&f_187, &f_336);
    cob_move (&f_186, &f_335);
    cob_move (&f_185, &f_334);
    cob_move (&f_196, &f_314);
    cob_move (&f_197, &f_313);
    cob_move (&f_202, &f_312);
    cob_move (&f_201, &f_311);
    cob_move (&f_199, &f_310);
    cob_move (&f_198, &f_309);
    cob_move (&f_200, &f_308);
    cob_move (&f_195, &f_307);
    cob_move (&f_194, &f_306);
    cob_move (&f_159, &f_294);
    cob_move (&f_157, &f_293);
    cob_move (&f_160, &f_292);
    cob_move (&f_155, &f_278);
    cob_move (&f_148, &f_276);
    cob_move (&f_143, &f_272);
    cob_move (&f_143, &f_267);
    cob_move (&f_143, &f_264);
    cob_move (&f_143, &f_259);
    cob_move (&f_143, &f_256);
    cob_move (&f_143, &f_254);
    cob_move (&f_143, &f_230);
    cob_move (&f_143, &f_228);
    cob_move (&f_143, &f_225);
    cob_move (&f_143, &f_216);
    cob_screen_display (&s_213, NULL, NULL);
  }
  /* OCic.cbl:1424: CALL */
  {
    {

      module.cob_procedure_parameters[0] = cob_intr_concatenate (0, 0, 2, cob_intr_trim (0, 0, &f_160, 2), &c_161);
      module.cob_procedure_parameters[1] = NULL;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      cob_call_params = 1;
      (*(int *) (b_1)) = CBL_DELETE_FILE (module.cob_procedure_parameters[0]->data);
    }
  }
  /* OCic.cbl:1427: MOVE */
  {
    (*(int *) (b_1)) = 0;
  }

  /* 213-Run-OCXref */

  /* OCic.cbl:1431: MOVE */
  {
    memset (b_155, 32, 80);
  }
  /* OCic.cbl:1432: CALL */
  {
    {

      module.cob_procedure_parameters[0] = &f_197;
      module.cob_procedure_parameters[1] = &f_196;
      module.cob_procedure_parameters[2] = &f_109;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      module.cob_procedure_parameters[5] = NULL;
      module.cob_procedure_parameters[6] = NULL;
      cob_call_params = 3;
      if (unlikely(call_LISTING.func_void == NULL)) {
        call_LISTING.func_void = cob_resolve ((const char *)"LISTING");
      }
      if (unlikely(call_LISTING.func_void == NULL))
        {
          /* OCic.cbl:1437: MOVE */
          {
            cob_move (&c_162, &f_155);
          }
          /* OCic.cbl:1439: MOVE */
          {
            (*(int *) (b_1)) = 1;
          }
        }
      else
        {
          (*(int *) (b_1)) = call_LISTING.funcint (b_182 + 160, b_182 + 159, b_109);
        }
    }
  }
  /* OCic.cbl:1441: IF */
  {
    if (((int)((*(int *) (b_1)) - 0) == 0))
      {
        /* OCic.cbl:1442: MOVE */
        {
          cob_move (&c_163, &f_155);
        }
        /* OCic.cbl:1444: IF */
        {
          if ((((int)cob_cmp_s32_binary (b_149, 1) == 0) || ((int)cob_cmp_s32_binary (b_149, 2) == 0)))
            {
              /* OCic.cbl:1445: MOVE */
              {
                memset (b_93, 32, 512);
              }
              /* OCic.cbl:1446: STRING */
              {
                cob_string_init (&f_93, 0);
                cob_string_delimited (0);
                cob_string_append (&c_164);
                cob_string_append (cob_intr_trim (0, 0, &f_160, 2));
                cob_string_append (&c_161);
                cob_string_finish ();
              }
              /* OCic.cbl:1452: CALL */
              {
                {

                  module.cob_procedure_parameters[0] = cob_intr_trim (0, 0, &f_93, 2);
                  module.cob_procedure_parameters[1] = NULL;
                  module.cob_procedure_parameters[2] = NULL;
                  module.cob_procedure_parameters[3] = NULL;
                  module.cob_procedure_parameters[4] = NULL;
                  cob_call_params = 1;
                  (*(int *) (b_1)) = SYSTEM (module.cob_procedure_parameters[0]->data);
                }
              }
            }
        }
      }
    else
      {
        /* OCic.cbl:1457: IF */
        {
          if (((int)cob_cmp (&f_155, &cob_space) == 0))
            {
              /* OCic.cbl:1458: MOVE */
              {
                cob_move (&c_165, &f_155);
              }
            }
        }
      }
  }
  /* OCic.cbl:1462: DISPLAY */
  {
    cob_move (&f_183, &f_351);
    cob_move (&f_192, &f_350);
    cob_move (&f_191, &f_340);
    cob_move (&f_190, &f_339);
    cob_move (&f_189, &f_338);
    cob_move (&f_188, &f_337);
    cob_move (&f_187, &f_336);
    cob_move (&f_186, &f_335);
    cob_move (&f_185, &f_334);
    cob_move (&f_196, &f_314);
    cob_move (&f_197, &f_313);
    cob_move (&f_202, &f_312);
    cob_move (&f_201, &f_311);
    cob_move (&f_199, &f_310);
    cob_move (&f_198, &f_309);
    cob_move (&f_200, &f_308);
    cob_move (&f_195, &f_307);
    cob_move (&f_194, &f_306);
    cob_move (&f_159, &f_294);
    cob_move (&f_157, &f_293);
    cob_move (&f_160, &f_292);
    cob_move (&f_155, &f_278);
    cob_move (&f_148, &f_276);
    cob_move (&f_143, &f_272);
    cob_move (&f_143, &f_267);
    cob_move (&f_143, &f_264);
    cob_move (&f_143, &f_259);
    cob_move (&f_143, &f_256);
    cob_move (&f_143, &f_254);
    cob_move (&f_143, &f_230);
    cob_move (&f_143, &f_228);
    cob_move (&f_143, &f_225);
    cob_move (&f_143, &f_216);
    cob_screen_display (&s_213, NULL, NULL);
  }
  /* OCic.cbl:1465: CALL */
  {
    {
      union {
        unsigned char data[8];
        long long     datall;
        int           dataint;
      } content_1;

      content_1.dataint = 2;
      module.cob_procedure_parameters[0] = &c_156;
      module.cob_procedure_parameters[1] = NULL;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      cob_call_params = 1;
      (*(int *) (b_1)) = cob_acuw_sleep (content_1.data);
    }
  }

  if (frame_ptr->perform_through == 51)
    goto *frame_ptr->return_address;

  /* 230-Run-Program SECTION */

  l_54:;

  /* 232-Build-Command */

  /* OCic.cbl:1476: MOVE */
  {
    memset (b_93, 32, 512);
  }
  /* OCic.cbl:1477: MOVE */
  {
    (*(int *)(b_144)) = 1;
  }
  /* OCic.cbl:1478: IF */
  {
    if ((((int)(int)(*(b_182 + 163) - 32) != 0) || ((int)(int)(*(b_182 + 158) - 32) != 0)))
      {
        /* OCic.cbl:1480: STRING */
        {
          cob_string_init (&f_93, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_166);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1485: IF */
  {
    if (((int)cob_cmp (&f_157, &cob_space) != 0))
      {
        /* OCic.cbl:1486: IF */
        {
          if ((((int)cob_cmp_s32_binary (b_149, 2) == 0) && ((int)(int)(*(b_157 + 1) - 58) == 0)))
            {
              /* OCic.cbl:1487: STRING */
              {
                cob_string_init (&f_93, &f_144);
                cob_string_delimited (0);
                cob_string_append (&c_167);
                cob_string_finish ();
              }
              /* OCic.cbl:1491: STRING */
              {
                cob_string_init (&f_93, &f_144);
                cob_string_delimited (0);
                cob_string_append (cob_intr_lower_case (0, 0, (f0.size = 1, f0.data = b_157 + 0, f0.attr = &a_2, &f0)));
                cob_string_finish ();
              }
              /* OCic.cbl:1495: PERFORM */
              {
                (*(int *)(b_145)) = 3;
                while (1)
                  {
                    if (((int)cob_cmp (&f_145, cob_intr_length (cob_intr_trim (0, 0, &f_157, 0))) >  0))
                      break;
                    {
                      /* OCic.cbl:1497: IF */
                      {
                        if (((int)(int)(*(b_157 + ((*(int *)(b_145)) - 1)) - 92) == 0))
                          {
                            /* OCic.cbl:1498: STRING */
                            {
                              cob_string_init (&f_93, &f_144);
                              cob_string_delimited (0);
                              cob_string_append (&c_133);
                              cob_string_finish ();
                            }
                          }
                        else
                          {
                            /* OCic.cbl:1503: STRING */
                            {
                              cob_string_init (&f_93, &f_144);
                              cob_string_delimited (0);
                              cob_string_append ((f0.size = 1, f0.data = b_157 + ((*(int *)(b_145)) - 1), f0.attr = &a_2, &f0));
                              cob_string_finish ();
                            }
                          }
                      }
                    }
                    (*(int *)(b_145)) = ((*(int *)(b_145)) + 1);
                  }
              }
            }
          else
            {
              /* OCic.cbl:1510: STRING */
              {
                cob_string_init (&f_93, &f_144);
                cob_string_delimited (0);
                cob_string_append (&c_91);
                cob_string_append (cob_intr_trim (0, 0, &f_157, 2));
                cob_string_finish ();
              }
            }
        }
        /* OCic.cbl:1515: STRING */
        {
          cob_string_init (&f_93, &f_144);
          cob_string_delimited (0);
          cob_string_append (&f_106);
          cob_string_finish ();
        }
      }
    else
      {
        /* OCic.cbl:1520: IF */
        {
          if ((((int)cob_cmp_s32_binary (b_149, 2) == 0) || ((int)cob_cmp_s32_binary (b_149, 3) == 0)))
            {
              /* OCic.cbl:1521: STRING */
              {
                cob_string_init (&f_93, &f_144);
                cob_string_delimited (0);
                cob_string_append (&c_168);
                cob_string_finish ();
              }
            }
        }
      }
  }
  /* OCic.cbl:1527: STRING */
  {
    cob_string_init (&f_93, &f_144);
    cob_string_delimited (0);
    cob_string_append (cob_intr_trim (0, 0, &f_160, 2));
    cob_string_finish ();
  }
  /* OCic.cbl:1531: IF */
  {
    if ((((int)(int)(*(b_182 + 163) - 32) == 0) && ((int)(int)(*(b_182 + 158) - 32) != 0)))
      {
        /* OCic.cbl:1533: STRING */
        {
          cob_string_init (&f_93, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_169);
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1538: IF */
  {
    if (((int)cob_cmp (&f_183, &cob_space) != 0))
      {
        /* OCic.cbl:1539: STRING */
        {
          cob_string_init (&f_93, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_138);
          cob_string_append (cob_intr_trim (0, 0, &f_183, 2));
          cob_string_finish ();
        }
      }
  }
  /* OCic.cbl:1544: IF */
  {
    if ((((int)cob_cmp_s32_binary (b_149, 0) == 0) || ((int)cob_cmp_s32_binary (b_149, 1) == 0)))
      {
        /* OCic.cbl:1545: STRING */
        {
          cob_string_init (&f_93, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_170);
          cob_string_finish ();
        }
      }
    else
      {
        /* OCic.cbl:1550: STRING */
        {
          cob_string_init (&f_93, &f_144);
          cob_string_delimited (0);
          cob_string_append (&c_171);
          cob_string_finish ();
        }
      }
  }

  /* 233-Run-Program */

  /* OCic.cbl:1558: DISPLAY */
  {
    cob_screen_display (&s_212, NULL, NULL);
  }
  /* OCic.cbl:1562: CALL */
  {
    {

      module.cob_procedure_parameters[0] = cob_intr_trim (0, 0, &f_93, 2);
      module.cob_procedure_parameters[1] = NULL;
      module.cob_procedure_parameters[2] = NULL;
      module.cob_procedure_parameters[3] = NULL;
      module.cob_procedure_parameters[4] = NULL;
      cob_call_params = 1;
      (*(int *) (b_1)) = SYSTEM (module.cob_procedure_parameters[0]->data);
    }
  }
  /* OCic.cbl:1565: PERFORM */
  {
    /* PERFORM 900-Terminate */
    frame_ptr++;
    frame_ptr->perform_through = 58;
    frame_ptr->return_address = &&l_167;
    goto l_58;
    l_167:
    frame_ptr--;
  }

  /* 239-Done */

  /* OCic.cbl:1569: EXIT */

  if (frame_ptr->perform_through == 54)
    goto *frame_ptr->return_address;

  /* 900-Terminate SECTION */

  l_58:;

  /* 901-Display-Message */

  /* OCic.cbl:1577: IF */
  {
    if (((int)cob_cmp (&f_155, &cob_space) >  0))
      {
        /* OCic.cbl:1578: DISPLAY */
        {
          cob_move (&f_183, &f_351);
          cob_move (&f_192, &f_350);
          cob_move (&f_191, &f_340);
          cob_move (&f_190, &f_339);
          cob_move (&f_189, &f_338);
          cob_move (&f_188, &f_337);
          cob_move (&f_187, &f_336);
          cob_move (&f_186, &f_335);
          cob_move (&f_185, &f_334);
          cob_move (&f_196, &f_314);
          cob_move (&f_197, &f_313);
          cob_move (&f_202, &f_312);
          cob_move (&f_201, &f_311);
          cob_move (&f_199, &f_310);
          cob_move (&f_198, &f_309);
          cob_move (&f_200, &f_308);
          cob_move (&f_195, &f_307);
          cob_move (&f_194, &f_306);
          cob_move (&f_159, &f_294);
          cob_move (&f_157, &f_293);
          cob_move (&f_160, &f_292);
          cob_move (&f_155, &f_278);
          cob_move (&f_148, &f_276);
          cob_move (&f_143, &f_272);
          cob_move (&f_143, &f_267);
          cob_move (&f_143, &f_264);
          cob_move (&f_143, &f_259);
          cob_move (&f_143, &f_256);
          cob_move (&f_143, &f_254);
          cob_move (&f_143, &f_230);
          cob_move (&f_143, &f_228);
          cob_move (&f_143, &f_225);
          cob_move (&f_143, &f_216);
          cob_screen_display (&s_213, NULL, NULL);
        }
        /* OCic.cbl:1581: CALL */
        {
          {
            union {
                unsigned char data[8];
                long long     datall;
                int           dataint;
            } content_1;

            content_1.dataint = 2;
            module.cob_procedure_parameters[0] = &c_156;
            module.cob_procedure_parameters[1] = NULL;
            module.cob_procedure_parameters[2] = NULL;
            module.cob_procedure_parameters[3] = NULL;
            module.cob_procedure_parameters[4] = NULL;
            cob_call_params = 1;
            (*(int *) (b_1)) = cob_acuw_sleep (content_1.data);
          }
        }
      }
  }
  /* OCic.cbl:1585: DISPLAY */
  {
    cob_screen_display (&s_212, NULL, NULL);
  }

  /* 909-Done */

  /* OCic.cbl:1591: GOBACK */
  {
    goto exit_program;
  }

  if (frame_ptr->perform_through == 58)
    goto *frame_ptr->return_address;

  /* Program exit */

  exit_program:

  /* Pop module stack */
  cob_current_module = cob_current_module->next;

  /* Program return */
  return (*(int *) (b_1));


  /* Default Error Handler */

  l_1:;

  if (!(cob_error_file->flag_select_features & COB_SELECT_FILE_STATUS)) {
        cob_default_error_handle ();
        cob_stop_run (1);
  }

  if (frame_ptr->perform_through == 1)
    goto *frame_ptr->return_address;

  cob_fatal_error (COB_FERROR_CODEGEN);

}

Here is the call graph for this function:

Here is the caller graph for this function:

 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines