{
  "SELECT with ACCESS MODE": {
    "prefix": "ACCESS MODE",
    "body": [
      "SELECT ${1:customerFile} ASSIGN TO ${2:custFile}",
      "\tORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL,LINE SEQUENTIAL|}",
      "\tACCESS MODE IS ${4|SEQUENTIAL,RANDOM,DYNAMIC|}",
      "\tFILE STATUS IS ${5:statusVariable}.",
      "$0"
    ],
    "description": "ACCESS MODE defines how records of the file are made available for processing your program. If ACCESS MODE is not specified Sequential (QSAM) is the default."
  },
  "ACCEPT": {
    "prefix": "ACCEPT variable",
    "body": ["ACCEPT ${1:variable}", "$0"],
    "description": "ACCEPT variable"
  },
  "ACCEPT FROM": {
    "prefix": "ACCEPT",
    "body": ["ACCEPT ${1:variable} FROM ${2|DATE,DAY,DAY-OF-WEEK,TIME|}", "$0"],
    "description": "ACCEPT is typically used to extract the current date/time from z/OS. The other primary use case is ACCEPT from the JOB Step's SYSIN. Each line in SYSIN is tied to an individual ACCEPT statement. There are numerous options for date/time formatting."
  },
  "ACCEPT id": {
    "prefix": "ACCEPT id",
    "body": ["ACCEPT ${1:id}", "$0"],
    "description": "ACCEPT id"
  },
  "ADDRESS OF": {
    "prefix": "ADDRESS OF",
    "body": ["ADDRESS OF ${1:id}"],
    "description": "The ADDRESS OF special register references the address of a data item in the linkage section, the local-storage section, or the working-storage section."
  },
  "ADD": {
    "prefix": "ADD",
    "body": ["ADD ${1:a} TO ${2:b} GIVING ${3:c}"],
    "description": "ADD a TO b GIVING c"
  },
  "ADD Id TO Id": {
    "prefix": "ADD id TO id",
    "body": ["ADD ${1:id} TO ${2:id}"],
    "description": "ADD literal TO id"
  },
  "ADD CORRESPONDING": {
    "prefix": "ADD CORRESPONDING",
    "body": ["ADD CORRESPONDING ${1:id} TO ${2:id}"],
    "description": "ADD CORRESPONDING is used to add the corresponding variables or fields in two identical group variables"
  },
  "ADD ON SIZE ERROR": {
    "prefix": "ADD SIZE ERROR",
    "body": [
      "ADD ${1:num-literal} TO ${2:num-var} ON SIZE ERROR ${3:error-catch-logic}"
    ],
    "description": "ADD is an alternative to the COMPUTE statement for simple math operations. ON SIZE ERROR checks for truncation in the sum."
  },
  "ADVANCING": {
    "prefix": "WRITE AFTER ADVANCING",
    "body": [
      "WRITE ${1:01-OUTPUT-RECORD} AFTER ADVANCING ${2:numLineLiteral} LINES END-WRITE.",
      "IF ${3:OUTPUT-RECORD-FILE-STATUS-CODE} NOT EQUAL 0",
      "\t${4:I/O-Error-Logic}",
      "END-IF."
    ],
    "description": "The WRITE AFTER ADVANCING phrase in the PROCEDURE DIVISION gives the COBOL programmer control over report file processing and pagination. Note that OUTPUT-RECORD-FILE-STATUS-CODE must be defined in the file FD and declared as a two-byte PIC XX field in the WORKING-STORAGE SECTION. This variable automates the process of validating each I/O action and z/OS updates its value after each action."
  },
  "AFTER FROM": {
    "prefix": "AFTER FROM",
    "body": ["AFTER ${1:item} FROM ${2:item}"],
    "description": "AFTER FROM"
  },
  "AFTER id": {
    "prefix": "AFTER id",
    "body": ["AFTER ${1:item}"],
    "description": "AFTER id"
  },
  "ALL BY": {
    "prefix": "ALL id BY id",
    "body": ["ALL ${1:id} BY ${2:id}"],
    "description": "ALL id BY id"
  },
  "ALLOCATE": {
    "prefix": "ALLOCATE item",
    "body": ["ALLOCATE ${1:arithExp|dataName}"],
    "description": "ALLOCATE item"
  },
  "ALPHABET": {
    "prefix": "ALPHABET IS",
    "body": ["ALPHABET ${1:variable-1} IS"],
    "description": "ALPHABET variable-1 IS"
  },
  "ALPHABETIC": {
    "prefix": "ALPHABETIC",
    "body": [
      "IF ${1:variable-1} IS ${2|ALPHABETIC,ALPHABETIC-LOWER,ALPHABETIC-UPPER|} THEN",
      "\t$0",
      "END-IF."
    ],
    "description": "A COBOL \"class test\" used to determine whether the contents of a variable contains specific upper/lower case values. Used in conjunction with CMPR2/NOCMPR2 as compilation directives."
  },
  "ALPHANUMERIC": {
    "prefix": "ALPHANUMERIC",
    "body": [
      "IF ${1:variable-1} IS ${2|ALPHANUMERIC,ALPHANUMERIC-EDITED|} THEN",
      "\t$0",
      "END-IF."
    ],
    "description": "A COBOL \"class test\" which is used to determine whether the contents of a variable only contain letters and numbers (no special characters)."
  },
  "ALSO": {
    "prefix": "ALSO item",
    "body": ["ALSO ${1|id,exp,TRUE,FALSE|}"],
    "description": "ALSO id|exp|TRUE|FALSE"
  },
  "ALTER TO": {
    "prefix": "ALTER TO",
    "body": ["ALTER ${1:procName-1} TO ${2:procName-2}"],
    "description": "ALTER TO"
  },
  "IF x AND y": {
    "prefix": "AND",
    "body": [
      "IF ${1:var-1} = ${2:'AB'} AND ${3:var-2} = ${4:'CD'} THEN",
      "\t$0",
      "END-IF."
    ],
    "description": "AND is used to connect two or more conditional expressions. When using AND all expressions connected by AND must test true for the program to take that path."
  },
  "AREA": {
    "prefix": "AREA",
    "body": ["${1|SAME,SAME SORT,SAME RECORD|} ${2|AREA,AREAS|}"],
    "description": "The AREA/AREAS keywords force z/OS to use the same main storage area for performing internal file processing. The three instances are syntax checked, but have no effect on the program at run-time."
  },
  "ASCENDING": {
    "prefix": "ASCENDING",
    "body": [
      "01 ${3:coboltbl}",
      "\t05 ${4:TBL-ROW} OCCURS ${5:numLiteral} TIMES",
      "\t\tASCENDING ${1:field-1} ${2:field-2}.",
      "$0"
    ],
    "description": "ASCENDING item"
  },
  "ASSIGN": {
    "prefix": "ASSIGN",
    "body": [
      "SELECT ${1:rptfile}",
      "\tASSIGN TO ${2:rptfile-DD}",
      "\tORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL,LINE SEQUENTIAL|}",
      "\tACCESS MODE IS ${4|SEQUENTIAL,RANDOM,DYNAMIC|}",
      "\tFILE STATUS IS ${5:statusVariable}.",
      "$0"
    ],
    "description": "FILE-CONTROL - ASSIGN item"
  },
  "BEFORE ADVANCING": {
    "prefix": "BEFORE ADVANCING",
    "body": [
      "WRITE ${1:01-OUTPUT-RECORD} BEFORE ADVANCING ${2:numLiteral} LINES",
      "END-WRITE.",
      "IF ${3:OUTPUT-RECORD-FILE-STATUS-CODE} NOT EQUAL 0 ${4:I/O-Error-Logic}",
      "END-IF."
    ],
    "description": "The WRITE BEFORE phrase in the PROCEDURE DIVISION gives the COBOL programmer control over file (most often report file) processing pagination. Note that OUTPUT-RECORD-FILE-STATUS-CODE must be defined in the file FD and declared as a two-byte (PIC XX) field in the WORKING-STORAGE SECTION. "
  },
  "BINARY": {
    "prefix": "BINARY",
    "body": ["${1:numvar} PIC 9(4) BINARY."],
    "description": "Variables defined with BINARY (and synonyms COMP and COMP-4) are a two's complement data representation in the COBOL language. This example provides two bytes of values in Base 16."
  },
  "BIT TO CHAR": {
    "prefix": "BIT-TO-CHAR",
    "body": [
      "01 ${1:BIT-FLD} PIC X(16).",
      "\tMOVE '${2:0000000000000000}' TO ${1:BIT-FLD}.",
      "\tFUNCTION BIT-TO-CHAR(${1:BIT-FLD})."
    ],
    "description": "Calls BIT-TO-CHAR to obtain a string that corresponds to the bit pattern stored in the PIC X field."
  },
  "BLANK WHEN ZERO": {
    "prefix": "BLANK",
    "body": ["01 ${1:variableName} PIC S9(5)V99 BLANK WHEN ZERO."],
    "description": "BLANK WHEN ZERO specifies that an elementary field contains spaces when its value is zero."
  },
  "BLOCK": {
    "prefix": "BLOCK",
    "body": ["BLOCK CONTAINS 0 RECORDS"],
    "description": "The BLOCK CONTAINS clause in the FD entry in the DATA DIVISION dictates the size of the physical (I/O) records. If you specify BLOCK CONTAINS 0, z/OS chooses the optimal \"blocking factor\" for most efficient file I/O, taking into account channels and DASD along with the file specifics."
  },
  "BOOLEAN": {
    "prefix": "JSON GENERATE FROM then CONVERT TO BOOLEAN",
    "body": [
      "JSON GENERATE ${1:fileJSON} FROM ${2:cobol-record}",
      "CONVERTING ${3:data-in-variable} TO BOOLEAN USING \"X\"."
    ],
    "description": "BOOLEAN as a reserved word is typically used to convert COBOL data to non-JSON data format."
  },
  "BOTTOM": {
    "prefix": "LINES AT BOTTOM",
    "body": ["LINES AT BOTTOM."],
    "description": "Part of the DATA DIVISION file FD, LINAGE clause, LINES AT BOTTOM tells COBOL to setup a bottom margin (blank lines at the bottom of every logical page)."
  },
  "BY": {
    "prefix": "BY",
    "body": ["BY ${1:item}"],
    "description": "BY Item"
  },
  "INDEXED BY": {
    "prefix": "BY",
    "body": [
      "01 ${1:TABLE-X}",
      "\t05 ${2:RECORD-X} OCCURS ${3:100} TIMES INDEXED BY ${4:X-IND}.",
      "\t\t10 ${5:elementary-items}"
    ],
    "description": "Defines an internal COBOL index for an internal COBOL table."
  },
  "SET x UP BY": {
    "prefix": "BY",
    "body": ["SET ${1:X-IND} UP BY ${2:1}"],
    "description": "Adds +1 an internal COBOL table's index, assuming INDEXED BY."
  },
  "STRING x DELIMITED BY y": {
    "prefix": "BY",
    "body": [
      "STRING ${1:VAR-1} DELIMITED BY ${2:VAR-2}",
      "\tINTO ${3:VAR-3}",
      "END-STRING."
    ],
    "description": "BY in the STRING (and UNSTRING) statements defines the transfer operation specifics: INTO VAR-3."
  },
  "BY UNTIL": {
    "prefix": "BY UNTIL",
    "body": ["BY ${1:item} UNTIL ${2:condition}"],
    "description": "BY item UNTIL condition"
  },
  "CHARACTERS BY": {
    "prefix": "CHARACTERS BY",
    "body": ["CHARACTERS BY ${1:id}"],
    "description": "CHARACTERS BY literal"
  },
  "CALL": {
    "prefix": "CALL",
    "body": [
      "CALL \"$1\" USING",
      "\tBY ${2|VALUE,REFERENCE,CONTENT|} ${3:identifier}",
      "\tRETURNING ${4:return-code}",
      "END-CALL",
      "$0"
    ],
    "description": "The CALL statement transfers control from one compiled program to another. Note that the BY and RETURNING clauses are optional. For more on CALL: "
  },
  "CANCEL": {
    "prefix": "CANCEL",
    "body": ["CANCEL ${1:id}.", "$0"],
    "description": "The CANCEL statement terminates the subprogram. This ensures that data in the subprogram reverts to its initial state the next time the subprogram is called. Also when a CANCEL statement is executed all called programs contained within the program referenced in the CANCEL statement are canceled."
  },
  "CHARACTERS": {
    "prefix": "CHARACTERS",
    "body": ["SYMBOLIC ${1|CHARACTER,CHARACTERS|} ${2:symbolic-character}"],
    "description": "ENVIRONMENT DIVISION / CONFIGURATION SECTION - SYMBOLIC CHARACTER"
  },
  "CLASS DIGIT IS": {
    "prefix": "CLASS",
    "body": ["CLASS DIGIT IS \"0\" THROUGH \"9\""],
    "description": ""
  },
  "CLOSE": {
    "prefix": "CLOSE",
    "body": ["CLOSE ${1:fileName}"],
    "description": "CLOSE filename"
  },
  "CODE SET": {
    "prefix": "CODE-SET",
    "body": ["FD CODE-SET IS ${1:ALPHABET-VAR-NM}.", "$0"],
    "description": "DATA DIVISION / FILE SECTION - CODE-SET is used in the COBOL DATA DIVISION, FILE SECTION, FD entry."
  },
  "COLLATING": {
    "prefix": "COLLATING",
    "body": ["PROGRAM COLLATING SEQUENCE IS ${1|EBCDIC,ASCII|}"],
    "description": "IDENTIFICATION DIVISION - COLLATING SEQUENCE determines the type of sequence used in operations on alphanumeric items. (EBCDIC vs. ASCII)"
  },
  "COMP": {
    "prefix": "COMP",
    "body": ["01 ${1:VAR-BIN} PIC S9(4) ${2|COMP,COMPUTATIONAL|}."],
    "description": "BINARY, and its synonyms COMP and COMP-4, are used next to numeric fields in the DATA DIVISION to specify that the data is represented in two's complement hex (EBCDIC) format."
  },
  "COMP-1": {
    "prefix": "COMP-1",
    "body": [
      "01 ${1:VAR-FLOAT-SINGLE-PREC} PIC S9(4) ${2|COMP,COMPUTATIONAL|}-1."
    ],
    "description": "A four-byte single-precision floating-point number declared in the DATA DIVISION."
  },
  "COMP-2": {
    "prefix": "COMP-2",
    "body": [
      "01 ${1:VAR-FLOAT-DOUBLE-PREC} PIC S9(4) ${2|COMP,COMPUTATIONAL|}-2."
    ],
    "description": "A four-byte double-precision floating-point number declared in the DATA DIVISION."
  },
  "COMP-3": {
    "prefix": "COMP-3",
    "body": [
      "01 ${1:VAR-PACKED-NUM-DATA} PIC S9(4) ${2|COMP,COMPUTATIONAL|}-3."
    ],
    "description": "Internally-packed (efficient) number declared in the DATA DIVISION."
  },
  "COMP-4": {
    "prefix": "COMP-4",
    "body": ["01 ${1:VAR-BIN} PIC S9(4) ${2|COMP,COMPUTATIONAL|}-4."],
    "description": "BINARY, and its synonyms COMP and COMP-4, are used next to numeric fields in the DATA DIVISION to specify that the data is represented in two's complement hex (EBCDIC) format."
  },
  "COMP-5": {
    "prefix": "COMP-5",
    "body": ["01 ${1:VAR-BIN} PIC S9(4) ${2|COMP,COMPUTATIONAL|}-5."],
    "description": "Typically used to communicate data between Java/C/C++/Python/etc. and COBOL. When numeric data is moved into a COMP-5 item, truncation occurs at the binary field size rather than at the COBOL picture clause declaration."
  },
  "COMPUTE": {
    "prefix": "COMPUTE",
    "body": [
      "COMPUTE ${1:NUM-VAR} = ${2:WS-NUMVAR1} ${3|+,-,*,/,**|} ${4:WS-NUMVAR2}",
      "\tON SIZE ERROR GO TO ${5:TRAP-OVERFLOW}",
      "\tNOT ON SIZE ERROR GO TO ${6:PROGRAM-FINAL-ACTION}",
      "END-COMPUTE",
      "$0"
    ],
    "description": "COMPUTE provides an algebraic-style keyword for the specification of complex arithmetic expressions: + (add), - (subtract), * (multiply), / (divide), ** (power of) and any intrinsic functions that return numeric results. ON SIZE ERROR allows you to trap situations such as divide by zero and result overflow."
  },
  "COMPUTE (CICS)": {
    "prefix": "COMPUTE",
    "body": [
      "COMPUTE ${1:NUM-VAR} OF ${2:DFHCOMMAREA} = ${3:WS-NUMVAR1} ${4|+,-,*,/,**|} ${5:WS-NUMVAR2}",
      "\tON SIZE ERROR GO TO ${6:TRAP-OVERFLOW}",
      "\tNOT ON SIZE ERROR GO TO ${7:PROGRAM-FINAL-ACTION}",
      "END-COMPUTE",
      "$0"
    ],
    "description": "COMPUTE provides an algebraic-style keyword for the specification of complex arithmetic expressions: + (add), - (subtract), * (multiply), / (divide), ** (power of) and any intrinsic functions that return numeric results. ON SIZE ERROR allows you to trap situations such as divide by zero and result overflow."
  },
  "COMPUTE EQUAL": {
    "prefix": "COMPUTE EQUAL",
    "body": ["COMPUTE ${1:id} EQUAL ${2:arithExp}"],
    "description": "COMPUTE id EQUAL arithexp"
  },
  "CONFIGURATION": {
    "prefix": "CONFIGURATION",
    "body": ["CONFIGURATION SECTION."],
    "description": "ENVIRONMENT DIVISION - The CONFIGURATION SECTION describes the z/OS environment on which the program is compiled and executed. It is an optional section for programs, functions, prototypes, and classes."
  },
  "CONTAINS": {
    "prefix": "CONTAINS",
    "body": [
      "FD ${2:inputFile}",
      "\tRECORD CONTAINS ${1:numLiteral} CHARACTERS",
      "\tBLOCK CONTAINS 0 RECORDS",
      "\tDATA RECORD IS ${3:inputFileRec}."
    ],
    "description": "A fixed-block file. Note that BLOCK CONTAINS 0 leaves the blocking-optimization up to z/OS and is the preferred way to specify most QSAM file FDs."
  },
  "CONTENT": {
    "prefix": "CONTENT",
    "body": ["CONTENT ${1:id}"],
    "description": "CONTENT id"
  },
  "CONTENT-OF": {
    "prefix": "CONTENT-OF",
    "body": [
      "COMPUTE ${1:resultNum} = CALC2(CONTENT-OF(${2:arg-1}),${3:arg-2},${4:arg-3})",
      "END-COMPUTE"
    ],
    "description": "The CONTENT-OF intrinsic function produces a temporary copy of the input argument."
  },
  "CONTINUE": {
    "prefix": "CONTINUE",
    "body": [
      "IF ${1:condition}",
      "\t${2:codeHere}",
      "ELSE",
      "\tCONTINUE",
      "END-IF."
    ],
    "description": "The CONTINUE statement is a no-op. It indicates that no instruction is present and that execution falls to the next sequential instruction."
  },
  "CONTROL": {
    "prefix": "CONTROL",
    "body": ["*CONTROL ${1|MAP,NOMAP|)"],
    "description": "*CONTROL is a compiler option which allows the user to limit (or not limit) the MAP output of a program compile. "
  },
  "CONVERTING": {
    "prefix": "CONVERTING",
    "body": [
      "INSPECT DATA-4 CONVERTING",
      "\"${1:abc}\" TO \"${2:123}\"",
      "AFTER INITIAL \"|\" BEFORE INITIAL \"/\"",
      "END-INSPECT",
      "$0"
    ],
    "description": "CONVERTING is a parameter of the INSPECT keyword. Used to replace character values."
  },
  "COPY": {
    "prefix": "COPY",
    "body": ["COPY ${1:copybookName}"],
    "description": "COPY is used to insert source code stored in a PDS or SCM into a COBOL program when it is compiled. Note that the JCL or Source Management System (Endevor, etc.) must be available and specified correctly during compilation."
  },
  "COPY REPLACING": {
    "prefix": "COPY REPLACING",
    "body": [
      "COPY \"${1:SUBPROG.CPY}\" REPLCAING",
      "\t ==${2:()}== BY ==${3:lnk-}==."
    ],
    "description": "COPY REPLACING"
  },
  "CORR": {
    "prefix": "CORR",
    "body": ["CORR ${1:id}"],
    "description": "CORR id"
  },
  "COUNT": {
    "prefix": "COUNT",
    "body": [
      "UNSTRING ${2:var-1} DELIMITED BY \"${3:*}\" INTO ${4:var-2}",
      "COUNT IN ${1:var-3}",
      "END-UNSTRING",
      "$0"
    ],
    "description": "Part of the UNSTRING statement, the COUNT phrase specifies the field where the count of examined character positions is held."
  },
  "COUNT IN": {
    "prefix": "COUNT IN",
    "body": ["COUNT IN ${1:id}"],
    "description": "COUNT IN id"
  },
  "CRT": {
    "prefix": "CRT",
    "body": ["CRT STATUS IS ${1:statusVar}"],
    "description": "Part of the SPECIAL-NAMES paragraph/CONFIGURATION SECTION in the ENVIRONMENT DIVISION. CRT STATUS returns data regarding the status of a screen-based COBOL ACCEPT statement when an ON EXCEPTION statement is included in the ACCEPT statement."
  },
  "CURRENCY": {
    "prefix": "CURRENCY",
    "body": [
      "CURRENCY SIGN IS \"${1:\\$USD}\" WITH PICTURE SYMBOL \"${2:\\$}\"."
    ],
    "description": "The CURRENCY SIGN clause is defined in the SPECIAL-NAMES paragraph in the CONFIGURATION SECTION of the ENVIRONMENT DIVISION. You can declare multiple currency signs for multiple currencies."
  },
  "CURSOR": {
    "prefix": "CURSOR",
    "body": ["CURSOR IS ${1:num-var-cursor-position}."],
    "description": "CURSOR IS is the name of a numeric data item described in the WORKING-STORAGE SECTION, which contains a value for placement of the cursor on a CRT. CURSOR IS is defined in the SPECIAL-NAMES paragraph."
  },
  "DATA DIVISION": {
    "prefix": "DATA DIVISION",
    "body": ["DATA DIVISION.", "$0"],
    "description": " DATA DIVISION"
  },
  "DATE": {
    "prefix": "DATE",
    "body": ["DATE ${1:yyyymmdd}"],
    "description": "DATE yyyymmdd"
  },
  "AT DATE": {
    "prefix": "AT DATE",
    "body": [
      "AT DATE * PERFORM",
      "    QUERY LOCATION;",
      "    LIST ${1:DATE-FIELD}",
      "    GO;",
      "END-PERFORM;"
    ],
    "description": "AT DATE is used with the IBM COBOL Debugger. It gives the Debugger control for each date processing statement within the specified block. In the above example: Each time a date processing statement is encountered in the compile unit; 1. Display the location of the statement 2. List a specific variable, and 3. Resume running the program."
  },
  "DATE COMPILED YYYY/MM/DD": {
    "prefix": "DATE COMPILED",
    "body": ["DATE-COMPILED. $CURRENT_YEAR/$CURRENT_MONTH/$CURRENT_DATE."],
    "description": "DATE-COMPILED is an optional statement in the IDENTIFICATION DIVISION that describes the specific date of program compilation."
  },
  "DATE COMPILED MM/DD/YYYY": {
    "prefix": "DATE COMPILED",
    "body": ["DATE-COMPILED. $CURRENT_MONTH/$CURRENT_DATE/$CURRENT_YEAR."],
    "description": "DATE-COMPILED is an optional statement in the IDENTIFICATION DIVISION that describes the specific date of program compilation."
  },
  "DATE WRITTEN YYYY/MM/DD": {
    "prefix": "DATE WRITTEN",
    "body": ["DATE-WRITTEN. $CURRENT_YEAR/$CURRENT_MONTH/$CURRENT_DATE."],
    "description": "DATE-WRITTEN is an optional statement in the IDENTIFICATION DIVISION that describes the specific date of program compilation."
  },
  "DATE WRITTEN MM/DD/YYYY": {
    "prefix": "DATE WRITTEN",
    "body": ["DATE-WRITTEN. $CURRENT_MONTH/$CURRENT_DATE/$CURRENT_YEAR."],
    "description": "DATE-WRITTEN is an optional statement in the IDENTIFICATION DIVISION that describes the specific date of program compilation."
  },
  "DAY": {
    "prefix": "DAY",
    "body": ["ACCEPT ${1:DATE-VAR-RECV} FROM DAY (${2:DATE-VAR-SEND})"],
    "description": "This is an example of utilizing a Julian Date receiving field (PIC 9(5) variable in the format YY NNN) from z/OS."
  },
  "DAY OF WEEK": {
    "prefix": "DAY OF WEEK",
    "body": ["ACCEPT ${1:DATE-VAR-RECV} FROM DAY-OF-WEEK (${2:DATE-VAR-SEND})"],
    "description": "This is an example of utilizing a one-byte (ie. PIC 9(1)) receiving variable (1-7) from z/OS. Note that 1 = Monday, 2 = Tuesday, 3 = Wednesday, etc."
  },
  "DBCS": {
    "prefix": "DBCS",
    "body": ["IF ${1:VAR-1} IS DBCS"],
    "description": "A class-condition, allowing you to test whether the data in a field is in valid DBCS format."
  },
  "DEBUG-ITEM (Simplified)": {
    "prefix": "DEBUG",
    "body": [
      "01 DEBUG-ITEM.",
      "\t05 DEBUG-${1|CONTENTS,NAME,SUB1,SUB2,SUB3|} PIC X(${2:nn})."
    ],
    "description": "The DEBUG-ITEM special register provides information for a debugging declarative procedure about the conditions that cause debugging section execution."
  },
  "DEBUG-ITEM (Implicit Description)": {
    "prefix": "DEBUG-ITEM",
    "body": [
      "01 DEBUG-ITEM.",
      "\t02 DEBUG-LINE PICTURE IS X(6).",
      "\t02 FILLER PICTURE IS X VALUE SPACE.",
      "\t02 DEBUG-NAME PICTURE IS X(30).",
      "\t02 FILLER PICTURE IS X VALUE SPACE.",
      "\t02 DEBUG-SUB-1 PICTURE IS S9999 SIGN IS LEADING SEPARATE CHARACTER.",
      "\t02 FILLER PICTURE IS X VALUE SPACE.",
      "\t02 DEBUG-SUB-2 PICTURE IS S9999 SIGN IS LEADING SEPARATE CHARACTER.",
      "\t02 FILLER PICTURE IS X VALUE SPACE.",
      "\t02 DEBUG-SUB-3 PICTURE IS S9999 SIGN IS LEADING SEPARATE CHARACTER.",
      "\t02 FILLER PICTURE IS X VALUE SPACE.",
      "\t02 DEBUG-CONTENTS PICTURE IS X(n)."
    ],
    "description": "The DEBUG-ITEM special register provides information for a debugging declarative procedure about the conditions that cause debugging section execution. This is the implicit description of the DEBUG-ITEM special register."
  },
  "DECIMAL-POINT": {
    "prefix": "DECIMAL-POINT",
    "body": ["DECIMAL-POINT IS COMMA."],
    "description": "Part of the SPECIAL-NAMES paragraph, the DECIMAL-POINT IS COMMA clause exchanges the functions of the period and the comma in PIC character-strings and in numeric literals."
  },
  "DECLARATIVES 1": {
    "prefix": "DECLARATIVES",
    "body": [
      "DECLARATIVES.",
      "${1:section-name} SECTION.",
      "USE FOR DEBUGGING ON ${2:OtherSectionhName}.",
      "${3:Debug-Declaratives-Section}.",
      "\tDisplay ${4:VAR1}, ${5:VAR2}, ${6:VAR3}.",
      "END-DECLARATIVES."
    ],
    "description": "Declaratives provide one or more special-purpose sections that are executed when an exception occurs."
  },
  "DECLARATIVES 2": {
    "prefix": "DECLARATIVES",
    "body": [
      "DECLARATIVES.",
      "${1:Debug-Declaratives} SECTION.",
      "USE FOR DEBUGGING ALL PROCEDURES.",
      "${2:Debug-Declaratives-section}.",
      "\tDisplay ${3:VAR1}, ${4:VAR2}, ${5:VAR3}.",
      "END-DECLARATIVES."
    ],
    "description": "Declaratives provide one or more special-purpose sections that are executed when an exception occurs."
  },
  "INITIALIZE DEFAULT": {
    "prefix": "DEFAULT",
    "body": ["INITIALIZE ${1:VAR1} TO DEFAULT."],
    "description": "PROCEDURE DIVISION - The INITIALIZE statement sets selected categories of data fields to predetermined values. The INITIALIZE statement is functionally equivalent to one or more MOVE statements."
  },
  "DELETE": {
    "prefix": "DELETE fileName",
    "body": ["DELETE ${1:fileName}", "END-DELETE."],
    "description": "Deletes a record from a file."
  },
  "DELIMITED BY": {
    "prefix": "DELIMITED BY",
    "body": ["DELIMITED BY ${1:item}"],
    "description": "DELIMITED BY item"
  },
  "DELIMITER": {
    "prefix": "DELIMITER",
    "body": ["RECORD DELIMITER IS ${1:STANDARD-1}"],
    "description": "DELIMITER IS"
  },
  "DEPENDING": {
    "prefix": "DEPENDING",
    "body": [
      "01 GROUP-VAR.",
      "\t05 ${1:CTR-1} PIC S9(4) COMP.",
      "\t05 ${2:VAR-TBL} DEPENDING ON ${1:CTR-1}.",
      "\t\t10 ${4:TBL-FLD1} PIC X(3).",
      "\t\t$0"
    ],
    "description": "OCCURS DEPENDING ON (ODO) specifies variable-length internal COBOL tables. "
  },
  "DESCENDING": {
    "prefix": "DESCENDING item",
    "body": [
      "01 ${1:BINARY-SORTED-TABLE}.",
      "\t05 ${2:TABLE-ROW-NAME} OCCURS ${3:5} TIMES",
      "\t\tDESCENDING ${4:KEY-3}",
      "\t\tINDEXED BY ${5:INDX-1}.",
      "\t\t10 ${6:CUST-NBR} PIC 9(6)"
    ],
    "description": "Using the binary (efficient) table SEARCH ALL option, DESCENDING declares that the internal COBOL table rows are sorted in descending order based upon values in a specified field within the table."
  },
  "DISPLAY": {
    "prefix": "DISPLAY",
    "body": [
      "IF ${1:FLD-2 = '....'}",
      "\tDISPLAY \"${2:messageHere}\"",
      "END-IF."
    ],
    "description": "Show the value of a COBOL variable on a screen or write it to an output file by using a DISPLAY statement."
  },
  "DISPLAY-1": {
    "prefix": "DISPLAY-1",
    "body": ["01 ${1:DBCS-FLD} PIC N(10) USAGE DISPLAY-1."],
    "description": "The DISPLAY-1 phrase defines an item as DBCS. The data item is stored in character form, with each character occupying 2 bytes of storage."
  },
  "DIVIDE": {
    "prefix": "DIVIDE",
    "body": [
      "DIVIDE ${1:NUMVAR-1} INTO ${2:NUMVAR-2}",
      "GIVING ${3:NUMVAR-3} ROUNDED",
      "ON SIZE ERROR ${3:imperative_statement}",
      "END-DIVIDE."
    ],
    "description": "In this example, NUMVAR-1 is divided by NUMVAR-2 and the result is stored in NUMVAR-3, rounded to the nearest whole number. If NUMVAR-1 = 0 or the quotient is larger than the pic-clause of NUMVAR-3, the ON SIZE ERROR is executed. That would typically be a GO TO statement referencing a paragraph written to handle errors such as this."
  },
  "DIVIDE BY GIVING": {
    "prefix": "DIVIDE BY GIVING",
    "body": ["DIVIDE ${1:id} BY ${2:id} GIVING ${3:id}"],
    "description": "DIVIDE BY GIVING"
  },
  "DIVIDE INTO": {
    "prefix": "DIVIDE INTO",
    "body": ["DIVIDE ${1:id} INTO ${2:id}"],
    "description": "DIVIDE INTO"
  },
  "DIVIDE INTO GIVING": {
    "prefix": "DIVIDE INTO GIVING",
    "body": ["DIVIDE ${1:id} INTO ${2:id} GIVING ${3:id}"],
    "description": "DIVIDE INTO GIVING"
  },
  "DIVIDE INTO GIVING REMAINDER": {
    "prefix": "DIVIDE INTO GIVING REMAINDER",
    "body": [
      "DIVIDE INTO GIVING REMAINDER=DIVIDE ${1:id} INTO ${2:id} GIVING ${3:id} REMAINDER ${4:id4}"
    ],
    "description": "DIVIDE INTO GIVING REMAINDER"
  },
  "DIVISION": {
    "prefix": "DIVISION",
    "body": ["${1|IDENTIFICATION,ENVIRONMENT,DATA,PROCEDURE|} DIVISION."],
    "description": "Required Headers for COBOL programs."
  },
  "SET x DOWN BY y": {
    "prefix": "DOWN BY",
    "body": ["SET ${1:indexName} DOWN BY ${2:numVarLiteral}"],
    "description": "DOWN BY item"
  },
  "ALTERNATE RECORD with DUPLICATES": {
    "prefix": "DUPLICATES",
    "body": ["ALTERNATE RECORD KEY IS ${1:FLD-1}", "WITH DUPLICATES."],
    "description": "DUPLICATES allows an indexed VSAM file to be defined with duplicate values declared in a defined variable within the record in the FD."
  },
  "SORT with DUPLICATES": {
    "prefix": "DUPLICATES",
    "body": [
      "SORT ${1:FILENAME} ON ${2|ASCENDING,DESCENDING|} ${3:KEY-FLD}",
      "WITH DUPLICATES${4|., IN ORDER.|}"
    ],
    "description": "IN ORDER forces the z/OS SORT utility to retain the original order of the input file, if duplicate key-field values are found. Note that IN ORDER is an optional clause of WITH DUPLICATES."
  },
  "DYNAMIC": {
    "prefix": "DYNAMIC",
    "body": [
      "SELECT ${1:VSAMFILE}",
      "ASSIGN TO ${2:JCLDDNAME}",
      "ORGANIZATION IS INDEXED",
      "ACCESS MODE IS DYNAMIC",
      "RECORD KEY IS ${3:VSAMFILE-KEY}",
      "FILE STATUS IS ${4:WS-VSAMFILE-FIELD}"
    ],
    "description": "Allows the specific READ/WRITE statement to determine the access mode. Records can be processed sequentially or randomly or both."
  },
  "EGCS": {
    "prefix": "EGCS",
    "body": [
      "INITIALIZE ${1:VAR1} REPLACING EGCS DATA BY ${2|literal,VAR-2|}",
      "END-INITIALIZE.",
      "$0"
    ],
    "description": "Initializes a variable while replacing the EGCS (Extended Graphic Character Set) information by a value or variable."
  },
  "IF-ELSE": {
    "prefix": "ELSE",
    "body": [
      "IF ${1:XisTrue}",
      "\t${2:codeHere}",
      "ELSE",
      "\t${3:codeHere}",
      "END-IF.",
      "$0"
    ],
    "description": "IF ... ELSE codes a choice between two COBOL processing actions."
  },
  "ENTRY": {
    "prefix": "ENTRY",
    "body": ["ENTRY ${1:literal}."],
    "description": "The ENTRY statement establishes an alternate entry point into a COBOL called subprogram."
  },
  "ENTRY USING": {
    "prefix": "ENTRY USING",
    "body": [
      "ENTRY ${1:literal} USING${2| , BY REFERENCE , BY VALUE |}${3:LINKAGE-DATA-ITEM}."
    ],
    "description": "The ENTRY statement establishes an alternate entry point into a COBOL called subprogram."
  },
  "ENVIRONMENT DIVISION": {
    "prefix": "ENVIRONMENT DIVISION",
    "body": ["ENVIRONMENT DIVISION.", "$0"],
    "description": "ENVIRONMENT DIVISION"
  },
  "ENCODING": {
    "prefix": "ENCODING item",
    "body": ["ENCODING ${1:item}"],
    "description": "ENCODING item"
  },
  "END-OF-PAGE": {
    "prefix": "END-OF-PAGE",
    "body": ["END-OF-PAGE ${1:item}"],
    "description": "END-OF-PAGE item"
  },
  "EOP": {
    "prefix": "EOP",
    "body": ["WRITE ${1:QSAM-RECORD} AT EOP."],
    "description": "EOP is a synonym for END-OF-PAGE."
  },
  "EQUAL": {
    "prefix": "EQUAL",
    "body": ["${1:var-1} EQUAL ${2:var-2}"],
    "description": "EQUAL two items"
  },
  "ERROR #1": {
    "prefix": "ERROR",
    "body": [
      "DIVIDE ${1:NUMVAR-1} INTO ${2:NUMVAR-2}",
      "GIVING ${3:NUMVAR-3}",
      "ON SIZE ERROR ${4:imperative_statement}",
      "END-DIVIDE."
    ],
    "description": "NUMVAR-1 is divided into NUMVAR-2. If NUMVAR-1 = 0 or if the quotient is larger than NUMVAR-3 the ON SIZE ERROR statement is executed. If ON SIZE ERROR is not coded, the program abends."
  },
  "ERROR #2": {
    "prefix": "ERROR",
    "body": [
      "MOVE CORRESPONDING ${1:GROUP-FIELDS-1} TO ${2:GROUP-FIELDS-2}",
      "ON SIZE ERROR ${3:imperative_statement}"
    ],
    "description": "The like-named variables in the COBOL group field GROUP-FIELDS-1 are moved to GROUP-FIELDS-2. If there are any variables in GROUP-FIELDS-1 that are larger than the same named variable in GROUP-FIELDS-2 the ON SIZE ERROR statement is executed. If ON SIZE ERROR is not coded, the program abends."
  },
  "ERROR #3": {
    "prefix": "ERROR",
    "body": [
      "USE AFTER ERROR PROCEDURE ON",
      "\t${1:file-name-1}",
      "\tINPUT OUTPUT",
      "\tI-O EXTEND"
    ],
    "description": "The EXCEPTION/ERROR declarative specifies procedures for input/output exception or error handling that are to be executed in addition to the standard z/OS procedures."
  },
  "EVERY (XML)": {
    "prefix": "EVERY",
    "body": [
      "XML GENERATE DOC FROM ${3:VAR-1}",
      "SUPPRESS SENSITIVEINFO",
      "\tEVERY ${1:NONNUMERIC ELEMENT WHEN SPACE}",
      "\tEVERY ${2:NUMERIC ELEMENT WHEN ZERO}",
      "END-XML."
    ],
    "description": "Part of the COBOL XML statement."
  },
  "EXCEPTION": {
    "prefix": "EXCEPTION",
    "body": ["EXCEPTION ${1:impStat}"],
    "description": "EXCEPTION impStat"
  },
  "EXCEPTION #1": {
    "prefix": "EXCEPTION",
    "body": ["CALL \"${2:SUBPROG}\" ON EXCEPTION ${1:impStatement}"],
    "description": "CALL x ON EXCEPTION y"
  },
  "EXCEPTION #2": {
    "prefix": "EXCEPTION",
    "body": [
      "01 ${2:DOCUMENT-VARIABLE} PIC X(500).",
      "\tXML GENERATE ${2:DOCUMENT-VARIABLE} FROM ${3:MSG-VARIABLE}",
      "\t\tWITH ATTRIBUTES ${4:attributesHere}",
      "\t\tON EXCEPTION ${1:impStatement}",
      "\tEND-XML.",
      "$0"
    ],
    "description": "An EXCEPTION condition occurs when the XML document cannot be generated."
  },
  "EXCEPTION #3": {
    "prefix": "EXCEPTION",
    "body": [
      "CLOSE ${2:fileName}",
      "\tON EXCEPTION ${1:impStatement}",
      "END-CLOSE",
      "$0"
    ],
    "description": "An EXCEPTION condition occurs when there is a problem closing a QSAM, VSAM or Line Sequential."
  },
  "EXIT": {
    "prefix": "EXIT",
    "body": ["EXIT."],
    "description": "EXIT statements close the PERFORM CHAIN (internal COBOL iterative control structure). Control is returned to the NSI (Next Sequential Instruction) following the PERFORM statement."
  },
  "EXIT PROGRAM": {
    "prefix": "EXIT PROGRAM",
    "body": ["EXIT PROGRAM."],
    "description": "EXIT PROGRAM transfers control outside the COBOL program."
  },
  "EXIT PROGRAM RETURNING": {
    "prefix": "EXIT PROGRAM",
    "body": ["EXIT PROGRAM RETURNING ${1:item}."],
    "description": "EXIT PROGRAM transfers control outside the COBOL program."
  },
  "EXIT METHOD": {
    "prefix": "EXIT METHOD",
    "body": ["EXIT METHOD."],
    "description": "EXIT METHOD transfers control outside the Object COBOL program."
  },
  "ARITH EXTEND": {
    "prefix": "EXTEND",
    "body": ["ARITH(EXTEND)"],
    "description": "A compiler directive that provides extended-precision function results that can accurately represent the value of the argument being returned."
  },
  "EXEC SQL": {
    "prefix": "EXEC SQL",
    "body": ["EXEC SQL", "\t${1:SQL-STATEMENT}", "END-EXEC."],
    "description": "EXEC SQL STATEMENT"
  },
  "EXEC SQL INCLUDE": {
    "prefix": "EXEC SQL INCLUDE",
    "body": ["EXEC SQL INCLUDE ${1:SQLSTATEMENT.CPY} END-EXEC."],
    "description": "EXEC SQL INCLUDE"
  },
  "EXEC CICS": {
    "prefix": "EXEC CICS",
    "body": ["EXEC CICS", "\t${1:cics-statement}", "END-EXEC."],
    "description": "EXEC CICS STATEMENT"
  },
  "EXTERNAL": {
    "prefix": "EXTERNAL",
    "body": ["01 ${1:DATA-NAME} EXTERNAL PIC X(${2:numberLiteral})."],
    "description": "The EXTERNAL clause specifies that the main storage associated with a data item is associated with the run unit rather than with any particular program."
  },
  "EVALUATE": {
    "prefix": "EVALUATE ",
    "body": [
      "EVALUATE $1",
      "\tWHEN $2",
      "\t\t$0",
      "\tWHEN OTHER",
      "\t\tCONTINUE",
      "END-EVALUATE",
      ""
    ],
    "description": "Use EVALUATE instead of a series of nested IF statements to test multiple conditions and specify distinct actions for each."
  },
  "EVALUATE FALSE": {
    "prefix": "EVALUATE FALSE",
    "body": [
      "EVALUATE FALSE",
      "\tWHEN ${1:VAR-A} = ${2:VAR-B}",
      "\t\t*> MOVE \"${1:VAR-A} - ${2:VAR-B} NOT EQUAL\" TO DISP-OUT",
      "\tWHEN ${3:VAR-C} = ${4:VAR-D}",
      "\t\t*> MOVE \"${3:VAR-C} - ${4:VAR-D} NOT EQUAL\" TO DISP-OUT",
      "END-EVALUATE.",
      "$0"
    ],
    "description": "Use EVALUATE instead of a series of nested IF statements to test multiple conditions and specify distinct actions for each."
  },
  "FD (QSAM)": {
    "prefix": "FD",
    "body": [
      "FD ${1:QSAM-FILE}",
      "\tLABEL RECORDS ARE STANDARD",
      "\tRECORDING MODE IS FBA",
      "\tBLOCK CONTAINS 0 RECORDS",
      "\tDATA RECORD IS ${2:RPT-OUT-REC}.",
      "01 ${2:RPT-OUT-REC} PIC X(${3:132})."
    ],
    "description": "DATA DIVISION - The FD describes files referred to in the PRODUCTION DIVISION's I/O statements."
  },
  "FD (VSAM)": {
    "prefix": "FD",
    "body": [
      "FD ${1:VSAM-FILE}",
      "\tRECORD CONTAINS ${2:numLiteral} CHARACTERS",
      "\tDATA RECORD IS ${3:RPT-OUT-REC}.",
      "01 ${3:RPT-OUT-REC}.",
      "\t05 FILLER PIC X(1)."
    ],
    "description": "DATA DIVISION - The VSAM FD describes files referred to in the PROCEDURE DIVISION's I/O statements."
  },
  "FILE": {
    "prefix": "FILE",
    "body": ["FILE ${1:item}"],
    "description": "FILE item"
  },
  "FILE SECTION": {
    "prefix": "FILE SECTION",
    "body": [
      "FILE SECTION.",
      "FD  ${1:MSTR-FILE}",
      "\tRECORD CONTAINS ${2:numLiteral} CHARACTERS",
      "\tDATA RECORD IS ${3:PATIENT-MASTER}."
    ],
    "description": "DATA DIVISION - The FILE SECTION is where you define specifics of each input/output file."
  },
  "FILE STATUS": {
    "prefix": "FILE STATUS",
    "body": [
      "SELECT ${2:rptfile}",
      "\tASSIGN TO ${1:PATVSAM}",
      "\tORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL,LINE SEQUENTIAL|}",
      "\tACCESS MODE IS ${4|SEQUENTIAL,RANDOM,DYNAMIC|}",
      "\tRECORD KEY IS ${5:PATIENT-REC-KEY}",
      "\tFILE STATUS IS ${1:PATVSAM}-FS."
    ],
    "description": "ENVIRONMENT DIVISION - FILE STATUS defines a two-byte (PIC XX) field that recieves a code from z/OS based on the disposition of the I/O operation."
  },
  "MULTIPLE FILE TAPE": {
    "prefix": "MULTIPLE FILE TAPE",
    "body": ["MULTIPLE FILE TAPE ${1:file1}, ${2:file2}"],
    "description": "ENVIRONMENT DIVISION / INPUT-OUTPUT SECTION / FILE-CONTROL - The MULTIPLE FILE TAPE clause specifies that 2 or mote data files, separated by commas, share the same physical volume serial of tape."
  },
  "FILE CONTROL": {
    "prefix": "FILE CONTROL",
    "body": [
      "SELECT ${1:FILE-1} ASSIGN TO ${2:EXTFILE1}",
      "ORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL,LINE SEQUENTIAL|}",
      "ACCESS MODE IS ${4|SEQUENTIAL,RANDOM,DYNAMIC|}",
      "FILE STATUS IS ${5:WS-FILE-STATUS-VAR}."
    ],
    "description": "ENVIRONMENT DIVISION / INPUT-OUTPUT SECTION / FILE-CONTROL - The FILE-CONTROL paragraph associates every file in your COBOL program with an external data set. It optionally defines file organization, access mode, etc."
  },
  "FILLER": {
    "prefix": "FILLER",
    "body": [
      "01 ${1:GROUP-ITEM}.",
      "\t05 ${2:ELEMENTARY-LINE}",
      "\t\t10 ${3:FIELD-1} PIC S9(${4:5}) COMP-3.",
      "\t\t10 FILLER PIC X(${5:20}) VALUE SPACE.",
      "\t\t$0"
    ],
    "description": "A placeholder variable that is not explicitly referred to in a program. FILLER is used to line up variable names with byte-offsets in the physical data record."
  },
  "FIRST #1": {
    "prefix": "FIRST",
    "body": ["FIRST ${1:id} BY ${2:id}"],
    "description": "FIRST ideral BY ideral"
  },
  "FIRST #2": {
    "prefix": "FIRST",
    "body": [
      "INSPECT ${1:VAR-1}",
      "TALLYING ${2:VAR-CTR} FOR LEADING \"${3:A}\"",
      "REPLACING FIRST \"${4:A1}\" BY \"${5:2}\" AFTER INITIAL \"${6:T}\""
    ],
    "description": "REPLACING FIRST changes the first (leftmost) occurrence of the inspected field (VAR-1 in this example)."
  },
  "FOOTING": {
    "prefix": "FOOTING",
    "body": ["WITH FOOTING AT ${1:literal}"],
    "description": "Part of the FD LINAGE (logical page size) clause. Available for QSAM and LINE SEQUENTIAL files only. WITH FOOTING specifies a line number in an output file or printer."
  },
  "FOR": {
    "prefix": "FOR",
    "body": ["FOR ${1:item}"],
    "description": "FOR item"
  },
  "FOR CHARACTERS AFTER": {
    "prefix": "FOR CHARACTERS AFTER",
    "body": [
      "INSPECT ${1:variable-field} TALLYING ${2:num-field}",
      "FOR CHARACTERS AFTER ${3:X\"40\"}"
    ],
    "description": "Counts the number of characters after the first occurrence of a specified string. Part of the TALLYING keyword in the INSPECT statement."
  },
  "USE FOR DEBUGGING": {
    "prefix": "USE FOR DEBUGGING",
    "body": [
      "DECLARATIVES.",
      "${1:Debug-Declaratives} SECTION.",
      "\tUSE FOR DEBUGGING ON ${2:paragraph-section-name}."
    ],
    "description": "PRODECURE DIVISION - Specifies debugging to begin on (specified) routine."
  },
  "CLOSE x FOR REMOVAL": {
    "prefix": "CLOSE x FOR REMOVAL",
    "body": ["CLOSE ${1:tape-file} FOR REMOVAL"],
    "description": "This phrase applies only to TAPE/REEL data sets and is treated as a comment."
  },
  "FROM": {
    "prefix": "FROM",
    "body": ["FROM ${1:item}"],
    "description": "FROM item"
  },
  "FROM #1": {
    "prefix": "FROM",
    "body": [
      "PERFORM ${1:B-100PARAGRAPH} VARYING ${2:IDX-1} FROM 1 BY 1 UNTIL ${2:IDX-1} > TABLE-MAX-ROWS"
    ],
    "description": "The \"FROM\" in a PERFORM VARYING clause sets the initial value and the incremental/iterative value(s) for a table subscript or index."
  },
  "FROM #2": {
    "prefix": "FROM",
    "body": [
      "${1|WRITE,REWRITE,RELEASE|} ${2:OUTPUT-REC} FROM ${3:WS-OUTPUT-REC}."
    ],
    "description": "The FROM phrase is equivalent to: MOVE REC-1 to OUTPUT-REC WRITE OUTPUT-REC."
  },
  "FROM #3": {
    "prefix": "FROM",
    "body": ["ACCEPT ${1:ws-receiving-field} FROM ${2|DATE,DAY,DAY-OF-WEEK|}."],
    "description": "This statement values the receiving-field with one of the system date registers."
  },
  "FREE": {
    "prefix": "FREE",
    "body": ["FREE ${1:dataName}"],
    "description": "FREE dataName"
  },
  "FUNCTION BIT-OF": {
    "prefix": "FUNCTION BIT-OF",
    "body": ["FUNCTION BIT-OF(${1:integer})$0"],
    "description": "FUNCTION TO CONVERT THE ARGUMENT TO BITS"
  },
  "FUNCTION BIT-TO-CHAR": {
    "prefix": "FUNCTION BIT-TO-CHAR",
    "body": ["FUNCTION BIT-TO-CHAR(${1:integer})$0"],
    "description": "FUNCTION TO CONVERT BITS TO CHARACTER"
  },
  "FUNCTION CHAR": {
    "prefix": "FUNCTION CHAR",
    "body": ["FUNCTION CHAR(${1:integer})$0"],
    "description": "FUNCTION CHARACTER IN THE ORDINAL POSITION SPECIFIED BY INTEGER, FROM THE CURRENT ALPHANUMERIC COLLATING SEQUENCE"
  },
  "FUNCTION COS": {
    "prefix": "FUNCTION COS",
    "body": ["FUNCTION COS(${1:angle})$0"],
    "description": "FUNCTION TRIGONOMETRIC COSINE OF ANGLE"
  },
  "FUNCTION CURRENCY-SYMBOL": {
    "prefix": "FUNCTION CURRENCY-SYMBOL",
    "body": ["FUNCTION CURRENCY-SYMBOL()$0"],
    "description": "FUNCTION CURRENCY-SYMBOL CHARACTER CURRENTLY IN EFFECT FOR THE LOCALE UNDER WHICH THE PROGRAM IS RUNNING"
  },
  "FUNCTION CURRENT-DATE": {
    "prefix": "FUNCTION CURRENT-DATE",
    "body": ["FUNCTION CURRENT-DATE(${1:date-and-time-format})$0"],
    "description": "FUNCTION CURRENT DATE AND TIME AS 21-CHARACTER VALUE"
  },
  "FUNCTION DATE-OF-INTEGER": {
    "prefix": "FUNCTION DATE-OF-INTEGER",
    "body": ["FUNCTION DATE-OF-integer(${1:integer})$0"],
    "description": "FUNCTION TO CONVERT THE INTEGER DATE TO STANDARD DATE FORMAT"
  },
  "FUNCTION DAY-OF-INTEGER": {
    "prefix": "FUNCTION DAY-OF-INTEGER",
    "body": ["FUNCTION DAY-OF-INTEGER(${1:integer})$0"],
    "description": "FUNCTION TO CONVERT THE INTEGER DATE TO NUMBER OF DAYS IN THE GREGORIAN CALENDAR"
  },
  "FUNCTION DAY-TO-YYYYDDD": {
    "prefix": "FUNCTION DAY-TO-YYYYDDD",
    "body": ["FUNCTION DATE--TO-YYYYDDD(${1:integer},${2:integer})$0"],
    "description": "FUNCTION TO CONVERT A DATE WITH A 2 DIGIT YEAR TO A 4 DIGIT YEAR"
  },
  "FUNCTION DISPLAY-OF": {
    "prefix": "FUNCTION DISPLAY-OF",
    "body": ["FUNCTION DISPLAY-OF(${1:string},${2:integer})$0"],
    "description": "FUNCTION TO CONVERT AN ALPHANUMERIC STRING USING A CODEPAGE"
  },
  "FUNCTION EXP": {
    "prefix": "FUNCTION EXP",
    "body": ["FUNCTION EXP(${1:integer})$0"],
    "description": "FUNCTION TO RETURN E RAISED TO THE POWER OF THE ARGUMENT"
  },
  "FUNCTION ABS": {
    "prefix": "FUNCTION ABS",
    "body": ["FUNCTION ABS(${1:number})$0"],
    "description": "FUNCTION ABSOLUTE VALUE OF NUMBER"
  },
  "FUNCTION ACOS": {
    "prefix": "FUNCTION ACOS",
    "body": ["FUNCTION ACOS(${1:COSINE})$0"],
    "description": "FUNCTION TRIGONOMETRIC ARC-COSINE, OR INVERSE COSINE, OF COSINE"
  },
  "FUNCTION ANNUITY": {
    "prefix": "FUNCTION ANNUITY",
    "body": ["FUNCTION ANNUITY(${1:INTEREST-RATE},${2:number-of-periods})$0"],
    "description": "FUNCTION ANNUITY"
  },
  "FUNCTION ASIN": {
    "prefix": "FUNCTION ASIN",
    "body": ["FUNCTION ASIN(${1:sine})$0"],
    "description": "FUNCTION TRIGONOMETRIC ARC-SINE, OR INVERSE SINE, OF SINE"
  },
  "FUNCTION ATAN": {
    "prefix": "FUNCTION ATAN",
    "body": ["FUNCTION ATAN(${1:tangent})$0"],
    "description": "FUNCTION TRIGONOMETRIC ARC-TANGENT, OR INVERSE TANGENT, OF TANGENT"
  },
  "FUNCTION BOOLEAN-OF-INTEGER": {
    "prefix": "FUNCTION BOOLEAN-OF-INTEGER",
    "body": ["FUNCTION BOOLEAN-OF-INTEGER(${1:integer},${2:LENGTH})$0"],
    "description": "FUNCTION BOOLEAN ITEM OF USAGE BIT REPRESENTING THE BINARY VALUE OF INTEGER; WITH THE GIVEN LENGTH"
  },
  "FUNCTION BYTE-LENGTH": {
    "prefix": "FUNCTION BYTE-LENGTH",
    "body": ["FUNCTION BYTE-LENGTH(${1:integer})$0"],
    "description": "FUNCTION BYTE-LENGTH (IN BYTES) OF ITEM"
  },
  "FUNCTION DATE-TO-YYYYMMDD": {
    "prefix": "FUNCTION DATE-TO-YYYYMMDD",
    "body": ["FUNCTION DATE--TO-YYYYMMDD(${1:integer},${2:integer})$0"],
    "description": "FUNCTION TO CONVERT A DATE WITH A 2 DIGIT YEAR TO A 4 DIGIT YEAR"
  },
  "FUNCTION EXP10": {
    "prefix": "FUNCTION EXP10",
    "body": ["FUNCTION EXP10(${1:integer})$0"],
    "description": "FUNCTION TO RETURN 10 RAISED TO THE POWER OF THE ARGUMENT"
  },
  "FUNCTION FACTORIAL": {
    "prefix": "FUNCTION FACTORIAL",
    "body": ["FUNCTION FACTORIAL(${1:integer})$0"],
    "description": "FUNCTION TO RETURN THE FACTORIAL OF THE ARGUMENT"
  },
  "FUNCTION HEX-OF": {
    "prefix": "FUNCTION HEX-OF",
    "body": ["FUNCTION HEX-OF(${1:variable})$0"],
    "description": "FUNCTION TO RETURN HEXADECIMAL REPRESENTATION OF THE ARGUMENT"
  },
  "FUNCTION HEX-TO-CHAR": {
    "prefix": "FUNCTION HEX-TO-CHAR",
    "body": ["FUNCTION HEX-TO-CHAR(${1:variable})$0"],
    "description": "FUNCTION TO RETURN A CHARACTER STRING THAT IS A HEXADECIMAL REPRESENTATION OF THE ARGUMENT"
  },
  "FUNCTION INTEGER": {
    "prefix": "FUNCTION INTEGER",
    "body": ["FUNCTION INTEGER(${1:number})$0"],
    "description": "GREATEST INTEGER VALUE THAT IS LESS THAN OR EQUAL TO NUMBER"
  },
  "FUNCTION INTEGER-OF-DATE": {
    "prefix": "FUNCTION INTEGER-OF-DATE",
    "body": ["FUNCTION INTEGER-OF-DATE(${1:yyyymmdd})$0"],
    "description": "CONVERTS YYYYMMDD TO AN INTERNAL INTEGER-DATE"
  },
  "FUNCTION INTEGER-OF-DAY": {
    "prefix": "FUNCTION INTEGER-OF-DAY",
    "body": ["FUNCTION INTEGER-OF-DAY(${1:yyyymmdd})$0"],
    "description": "CONVERTS YYYYMMDD TO AN INTERNAL INTEGER-DAY"
  },
  "FUNCTION INTEGER-PART": {
    "prefix": "FUNCTION INTEGER-PART",
    "body": ["FUNCTION INTEGER-PART(${1:number})$0"],
    "description": "PORTION OF NUMBER THAT OCCURS TO THE LEFT OF THE DECIMAL POINT"
  },
  "FUNCTION LENGTH": {
    "prefix": "FUNCTION LENGTH",
    "body": ["FUNCTION LENGTH(${1:item})$0"],
    "description": "RETURNS THE LENGTH (IN CHARACTER POSITIONS) OF THE SPECIFIED ITEM"
  },
  "FUNCTION LOG": {
    "prefix": "FUNCTION LOG",
    "body": ["FUNCTION LOG(${1:number})$0"],
    "description": "FORMAT BASE E LOGARITHM OF NUMBER"
  },
  "FUNCTION LOG10": {
    "prefix": "FUNCTION LOG10",
    "body": ["FUNCTION LOG10(${1:number})$0"],
    "description": "FORMAT BASE 10 LOGARITHM OF NUMBER"
  },
  "FUNCTION LOWERCASE": {
    "prefix": "FUNCTION LOWERCASE",
    "body": ["FUNCTION LOWERCASE(${1:string})$0"],
    "description": "CHARACTER STRING THAT CONTAINS STRING WITH ANY UPPERCASE LETTERS REPLACED BY THEIR CORRESPONDING LOWERCASE LETTERS"
  },
  "FUNCTION MAX": {
    "prefix": "FUNCTION MAX",
    "body": ["FUNCTION MAX(${1:number},${2:...})$0"],
    "description": "ALPHANUMERIC/INDEX/INTEGER/NATIONAL/NUMERIC MAXIMUM VALUE FROM THE SPECIFIED LIST OF NUMBERS"
  },
  "FUNCTION MEAN": {
    "prefix": "FUNCTION MEAN",
    "body": ["FUNCTION MEAN(${1:number},${2:...})$0"],
    "description": "STATISTICAL MEAN VALUE OF THE SPECIFIED LIST OF NUMBERS"
  },
  "FUNCTION MEDIAN": {
    "prefix": "FUNCTION MEDIAN",
    "body": ["FUNCTION MEDIAN(${1:number},${2:...})$0"],
    "description": "STATISTICAL MEDIAN VALUE OF THE SPECIFIED LIST OF NUMBERS"
  },
  "FUNCTION MIDRANGE": {
    "prefix": "FUNCTION MIDRANGE",
    "body": ["FUNCTION MIDRANGE(${1:number},${2:...})$0"],
    "description": "STATISTICAL MIDRANGE VALUE OF THE SPECIFIED LIST OF NUMBERS"
  },
  "FUNCTION MIN": {
    "prefix": "FUNCTION MIN",
    "body": ["FUNCTION MIN(${1:number},${2:...})$0"],
    "description": "STATISTICAL MIN VALUE OF THE SPECIFIED LIST OF NUMBERS"
  },
  "FUNCTION MOD": {
    "prefix": "FUNCTION MOD",
    "body": ["FUNCTION MOD(${1:value},${2:modulus})$0"],
    "description": "REMAINDER FROM THE DIVISION OF VALUE BY MODULUS"
  },
  "FUNCTION NATIONAL-OF": {
    "prefix": "FUNCTION NATIONAL-OF",
    "body": [
      "FUNCTION NATIONAL-OF(${1:alphanumeric-string},${2:replacement-char})$0"
    ],
    "description": "CONVERT ALPHANUMERIC-STRING TO THE NATIONAL CODED CHARACTER SET REPRESENTATION"
  },
  "FUNCTION NUMVAL": {
    "prefix": "FUNCTION NUMVAL",
    "body": ["FUNCTION NUMVAL(${1:string})$0"],
    "description": "CORRESPONDING NUMERIC VALUE FOR STRING"
  },
  "FUNCTION NUMVAL-C": {
    "prefix": "FUNCTION NUMVAL-C",
    "body": [
      "FUNCTION NUMVAL-C(${1:string},${2:currency-symbol}${3:,anycase})$0"
    ],
    "description": "CORRESPONDING NUMERIC VALUE FOR STRING, CASE-SENSITIVE IF ANYCASE NOT GIVEN"
  },
  "FUNCTION NUMVAL-F": {
    "prefix": "FUNCTION NUMVAL-F",
    "body": ["FUNCTION NUMVAL-F(${1:string})$0"],
    "description": "CORRESPONDING NUMERIC VALUE FOR FLOATING-POINT-STRING"
  },
  "FUNCTION ORD": {
    "prefix": "FUNCTION ORD",
    "body": ["FUNCTION ORD(${1:char},${2:...})$0"],
    "description": "ORDINAL POSITION IN THE PROGRAM CHARACTER SET CORRESPONDING TO CHAR"
  },
  "FUNCTION ORD-MAX": {
    "prefix": "FUNCTION ORD-MAX",
    "body": ["FUNCTION ORD-MAX(${1:char},${2:...})$0"],
    "description": "MAX. ORDINAL POSITION IN THE PROGRAM CHARACTER SET CORRESPONDING TO LIST OF CHARS"
  },
  "FUNCTION ORD-MIN": {
    "prefix": "FUNCTION ORD-MIN",
    "body": ["FUNCTION ORD-MIN(${1:char},${2:...})$0"],
    "description": "MIN. ORDINAL POSITION IN THE PROGRAM CHARACTER SET CORRESPONDING TO LIST OF CHARS"
  },
  "FUNCTION PI": {
    "prefix": "FUNCTION PI",
    "body": ["FUNCTION PI()$0"],
    "description": "PI"
  },
  "FUNCTION PRESENT-VALUE": {
    "prefix": "FUNCTION PRESENT-VALUE",
    "body": [
      "FUNCTION PRESENT-VALUE(${1:discount-rate},${2:amount},${3:...})$0"
    ],
    "description": "APPROXIMATION OF THE PRESENT VALUE OF A SERIES OF FUTURE PERIOD-END AMOUNT"
  },
  "FUNCTION RANDOM": {
    "prefix": "FUNCTION RANDOM",
    "body": ["FUNCTION RANDOM(${1:seed})$0"],
    "description": "PSEUDO-RANDOM NUMBER 0> <1 FROM A RECTANGULAR DISTRIBUTION WITH OPTIONAL SEED"
  },
  "FUNCTION RANGE": {
    "prefix": "FUNCTION RANGE",
    "body": ["FUNCTION RANGE(${1:argument},${2:...})$0"],
    "description": "VALUE OF THE MAXIMUM ARGUMENT MINUS THE VALUE OF THE MINIMUM ARGUMENT"
  },
  "FUNCTION REM": {
    "prefix": "FUNCTION REM",
    "body": ["FUNCTION REM(${1:number},${2:divisor})$0"],
    "description": "REMAINDER OF NUMBER DIVIDED BY DIVISOR"
  },
  "FUNCTION REVERSE": {
    "prefix": "FUNCTION REVERSE",
    "body": ["FUNCTION REVERSE(${1:string})$0"],
    "description": "REVERSE REPRESENTATION WITH SAME LENGTH OF STRING"
  },
  "FUNCTION SIGN": {
    "prefix": "FUNCTION SIGN",
    "body": ["FUNCTION SIGN(${1:number})$0"],
    "description": "SIGN REPRESENTATION OF NUMBER AS -1, 0, 1"
  },
  "FUNCTION SIN": {
    "prefix": "FUNCTION SIN",
    "body": ["FUNCTION SIN(${1:angle})$0"],
    "description": "TRIGONOMETRIC SINE OF THE SPECIFIED ANGLE"
  },
  "FUNCTION STANDARD-DEVIATION": {
    "prefix": "FUNCTION STANDARD-DEVIATION",
    "body": ["FUNCTION STANDARD-DEVIATION(${1:integer})$0"],
    "description": "FUNCTION TO RETURN THE STANDARD DEVIATION OF ITS ARGUMENTS"
  },
  "FUNCTION SQRT": {
    "prefix": "FUNCTION SQRT",
    "body": ["FUNCTION SQRT(${1:number})$0"],
    "description": "APPROXIMATION OF THE SQUARE ROOT OF NUMBER"
  },
  "FUNCTION SUM": {
    "prefix": "FUNCTION SUM",
    "body": ["FUNCTION SUM(${1:integer})$0"],
    "description": "FUNCTION TO RETURN THE SUM OF ITS ARGUMENTS"
  },
  "FUNCTION TAN": {
    "prefix": "FUNCTION TAN",
    "body": ["FUNCTION TAN(${1:angle})$0"],
    "description": "TRIGONOMETRIC TANGENT OF THE SPECIFIED ANGLE"
  },
  "FUNCTION TEST-NUMVAL": {
    "prefix": "FUNCTION TEST-NUMVAL",
    "body": ["FUNCTION TEST-NUMVAL(${1:integer})$0"],
    "description": "FUNCTION TO VERIFY THE CONTENTS OF THE ARGUMENT"
  },
  "FUNCTION TEST-NUMVAL-F": {
    "prefix": "FUNCTION TEST-NUMVAL-F",
    "body": ["FUNCTION TEST-NUMVAL-F(${1:integer})$0"],
    "description": "FUNCTION TO VERIFY THE CONTENTS OF THE ARGUMENT"
  },
  "FUNCTION TRIM": {
    "prefix": "FUNCTION TRIM",
    "body": ["FUNCTION TRIM(${1:variable})$0"],
    "description": "FUNCTION TO TRIM LEADING AND OR TRAILING SPACES OF THE ARGUMENT"
  },
  "FUNCTION ULENGTH": {
    "prefix": "FUNCTION ULENGTH",
    "body": ["FUNCTION ULENGTH(${1:variable})$0"],
    "description": "FUNCTION TO RETURN THE NUMBER OF UTF8 OR UTF16 CHARACTERS OF THE ARGUMENT"
  },
  "FUNCTION UPOS": {
    "prefix": "FUNCTION UPOS",
    "body": ["FUNCTION UPOS(${1:string},${2:integer})$0"],
    "description": "FUNCTION TO RETURN AN INTEGER VALUE EQUAL TO THE POSITION OF THE NTH ITEM IN THE PASSED UTF8 OR UTF16 ARGUMENT"
  },
  "FUNCTION UPPER-CASE": {
    "prefix": "FUNCTION UPPER-CASE",
    "body": ["FUNCTION UPPER-CASE(${1:variable})$0"],
    "description": "FUNCTION TO RETURN THE ARGUMENT IN UPPER CASE"
  },
  "FUNCTION USUBSTR": {
    "prefix": "FUNCTION USUBSTR",
    "body": ["FUNCTION USUBSTR(${1:variable},${2:integer},$(3:integer)$0"],
    "description": "FUNCTION TO RETURN SUBSTRING OF THE CHARACTER DATA PASSED THAT CONTAINS UTF8 OR UTF16 DATA"
  },
  "FUNCTION USUPPLEMENTARY": {
    "prefix": "FUNCTION USUPPLEMENTARY",
    "body": ["FUNCTION USUPPLEMENTARY(${1:variable})$0"],
    "description": "FUNCTION TO RETURN AN INTEGER VALUE EQUATING TO THE INDEX OF THE FIRST UNICODE CHARACTER OF THE ARGUMENT"
  },
  "FUNCTION UVALID": {
    "prefix": "FUNCTION UVALID",
    "body": ["FUNCTION UVALID(${1:variable})$0"],
    "description": "FUNCTION TO RETURN AN INTEGER VALUE EQUATING TO THE INDEX OF THE FIRST INVALID UNICODE CHARACTER OF THE ARGUMENT"
  },
  "FUNCTION UWIDTH": {
    "prefix": "FUNCTION UWIDTH",
    "body": ["FUNCTION UWIDTH(${1:STRING},${2:integer})$0"],
    "description": "FUNCTION TO RETURN AN INTEGER VALUE EQUAL TO THE WIDTH IN BYTES OF THE NTH ITEM IN THE PASSED UTF8 OR UTF16 ARGUMENT"
  },
  "FUNCTION VARIANCE": {
    "prefix": "FUNCTION VARIANCE",
    "body": ["FUNCTION VARIANCE(${1:number},${2:...})$0"],
    "description": "STATISTICAL VARIANCE OF THE SPECIFIED LIST OF NUMBER ARGUMENT"
  },
  "FUNCTION YEAR-TO-YYYY": {
    "prefix": "FUNCTION YEAR-TO-YYYY",
    "body": [
      "FUNCTION YEAR-TO-YYYY(${1:YY},${2:[YY-CUTOFF, DEFAULT: 50},${3:YY-EXECUTION-TIME, DEFAULT: NOW})$0"
    ],
    "description": "CONVERT YY TO YYYY WITH OPTIONAL YY-CUTOFF TO DELINEATE CENTURIES"
  },
  "FUNCTION-POINTER": {
    "prefix": "FUNCTION-POINTER",
    "body": ["01 ${1:DATA-FUNCTION-PTR} USAGE FUNCTION-POINTER."],
    "description": "A FUNCTION-POINTER is a 4-byte elementary item which can contain the address of a procedure (typically a program) entry point."
  },
  "JSON GENERATE": {
    "prefix": "GENERATE",
    "body": [
      "JSON GENERATE ${1:JSON-STMT} FROM ${2:IN-FILE-TEXT} IN ${3:JSON-CHAR-CTR}",
      "\tON EXCEPTION ${4:DISPLAY 'JSON GENERATE ERROR: ' WS-JS-CODE}",
      "END-JSON"
    ],
    "description": "Manipulate COBOL data items as JSON text by using the JSON GENERATE statement."
  },
  "XML GENERATE": {
    "prefix": "XML GENERATE",
    "body": [
      "XML GENERATE ${1:XML-DATA} FROM ${2:IN-FILE-TEXT} IN ${3:XML-CHAR-CTR}",
      "\tON EXCEPTION ${4:DISPLAY 'XML TRANSLATE ERROR: ' WS-XML-CODE}",
      "\tGO TO ${5:XML-ERROR-PARAGRAPH}",
      "END-XML."
    ],
    "description": "Use an XML GENERATE statement to transform COBOL data to XML."
  },
  "GIVING": {
    "prefix": "GIVING",
    "body": ["GIVING ${1:item}"],
    "description": "GIVING item"
  },
  "GOBACK": {
    "prefix": "GOBACK",
    "body": [
      "IF ${1:WS-STATUS-CODE NOT EQUAL 0} THEN",
      "\t${2:statement}",
      "\tGOBACK."
    ],
    "description": "Ends program and returns control to the application module that invoked the program. If this is a standalone batch program, GOBACK returns control to z/OS."
  },
  "GO DEPENDING": {
    "prefix": "GO DEPENDING",
    "body": ["GO ${1:procName} DEPENDING ${2:id}"],
    "description": "GO procName DEPENDING id"
  },
  "GREATER": {
    "prefix": "GREATER",
    "body": [
      "IF ${1:VAR1} GREATER THAN ${2:VAR2} THEN",
      "\t${3:ifTrue}",
      "END-IF.",
      "$0"
    ],
    "description": "GREATER is a general comparison operator. Treated like the algebraic \">\" operator."
  },
  "GROUP-USAGE": {
    "prefix": "GROUP-USAGE",
    "body": [
      "01 ${1:NAT-GROUP-1} GROUP-USAGE ${2|NATIONAL,UTF-8|}.",
      "\t02 ${3:GROUP-1}.",
      "\t\t04 ${4:groupVar} PIC ${5:99}."
    ],
    "description": "A group item that is described with an explicit or implicit GROUP-USAGE NATIONAL clause is a national group item. Note that NATIONAL data items are represented as UTF-16 characters. "
  },
  "HIGH-VALUES": {
    "prefix": "HIGH-VALUES",
    "body": [
      "READ ${1:IN-FILE} AT ${2|END,BEGINNING|} MOVE HIGH-VALUES TO ${3:INPUT-REC}."
    ],
    "description": "HIGH-VALUE equates to binary (Hex) FF. The highest EBCDIC collating sequence value."
  },
  "I-O": {
    "prefix": "I-O",
    "body": ["OPEN I-O ${1:fileName}"],
    "description": "Use the input-output file mode to rewrite QSAM and VSAM file records in place."
  },
  "ID DIVISION": {
    "prefix": "ID DIVISION",
    "body": [
      "IDENTIFICATION DIVISION.",
      "PROGRAM-ID. ${1:${TM_FILENAME/(.*)\\..+$/${2:/UPCASE}/}}.",
      "DATE-COMPILED. $CURRENT_YEAR/$CURRENT_MONTH/$CURRENT_DATE.",
      "$0"
    ],
    "description": "The IDENTIFICATION DIVISION contains the PROGRAM-ID, AUTHOR, INSTALLATION, DATE-WRITTEN, and SECURITY paragraphs."
  },
  "INPUT": {
    "prefix": "INPUT",
    "body": ["INPUT ${1:fileName}"],
    "description": "INPUT fileName"
  },
  "INPUT PROCEDURE": {
    "prefix": "INPUT PROCEDURE",
    "body": ["INPUT PROCEDURE ${1:procName}"],
    "description": "INPUT PROCEDURE"
  },
  "INSPECT CONVERTING": {
    "prefix": "INSPECT ID CONVERTING",
    "body": [
      "INSPECT ${1:id}",
      "\tCONVERTING '${2:abcdefg}' TO '${3:ABCDEFG}",
      "\tAFTER INITIAL '${4:|}' BEFORE INITIAL '${5:/}'."
    ],
    "description": "INSPECT is a string parsing verb for alphanumeric fields."
  },
  "INSPECT REPLACING": {
    "prefix": "INSPECT REPLACING",
    "body": [
      "INSPECT ${1:id} ${2|REPLACING,REPLACING ALL LOW-VALUES BY|} ${3:SNIP}"
    ],
    "description": "INSPECT is a string parsing verb for alphanumeric fields."
  },
  "INSPECT TALLYING": {
    "prefix": "INSPECT",
    "body": [
      "INSPECT ${1:id}",
      "TALLYING ${2:VAR-CTR} FOR LEADING \"${3:A}\"",
      "REPLACING FIRST \"${4:A1}\" BY \"${5:2}\" AFTER INITIAL \"${6:T}\""
    ],
    "description": "When FIRST is specified and not BEFORE or AFTER, The replacement field changes the left/first occurrence of the inspected field."
  },
  "IDENTIFICATION DIVISION": {
    "prefix": "IDENTIFICATION-DIVISION",
    "body": ["IDENTIFICATION DIVISION.", "$0"],
    "description": "IDENTIFICATION-DIVISION"
  },
  "IF": {
    "prefix": "IF",
    "body": ["IF ${1:CONDITION}", "\t${2:ifTrue}", "END-IF"],
    "description": "IF"
  },
  "IF ELSE": {
    "prefix": "IF",
    "body": [
      "IF ${1:CONDITION}",
      "\t${2:ifTrue}",
      "ELSE",
      "\t${3:ifFalse}",
      "END-IF"
    ],
    "description": "IF ELSE"
  },
  "IN #1": {
    "prefix": "IN",
    "body": [
      "UNSTRING ${1:CUST-TRANS} DELIMITED BY \"${2:|}\"",
      "\tINTO ${3:CUST-REC-IN}",
      "COUNT IN ${4:CTR-1}",
      "END UNSTRING."
    ],
    "description": "COUNT IN references an integer field that contains the number of characters placed in the current receiving field."
  },
  "IN #2": {
    "prefix": "IN",
    "body": [
      "UNSTRING ${1:CUST-FIELD-IN} DELIMITED ${2|BY,BY ALL|} \"${3:|}\" OR \"${4:/}\"",
      "\tINTO ${5:CUST-NAME} COUNT IN ${6:CTR-1} DELIMITER IN ${7:DLM-CHAR}",
      "END-UNSTRING.",
      "$0"
    ],
    "description": "DELIMITER IN references a PIC X field that contains the DELIMITER character placed in the UNSTRING field."
  },
  "IN #3": {
    "prefix": "IN #3",
    "body": [
      "UNSTRING ${1:CUST-FIELD-IN} DELIMITED BY ALL  \"|\" OR \"/\"",
      "\t${2:INTO CUST-NAME} COUNT IN ${3:CTR-1}",
      "\t${4:CUST-ADDR} DELIMITER IN ${5:DLM-CHR}",
      "TALLYING IN ${6:TOT-FIELDS-FOUND}",
      "END-UNSTRING."
    ],
    "description": "TALLYING IN references a numeric field that contains a total of the number of fields that are acted on during the UNSTRING."
  },
  "INDEX": {
    "prefix": "INDEX",
    "body": ["01 ${1:TBL-IDX} USAGE IS INDEX."],
    "description": "USAGE IS INDEX creates an index data item, which can used as an index variable into any COBOL internal table (OCCURS clause)."
  },
  "OCCURS x INDEXED BY": {
    "prefix": "INDEXED",
    "body": [
      "01 ${1:GROUP-FIELD}",
      "\t05 ${2:TABLE-ITEM} PIC ${3:X(1)}",
      "\t\tOCCURS ${4:100} INDEXED BY ${5:IDX-BTYE}"
    ],
    "description": "INDEXED BY defines an internal COBOL index data item and associates it with a given COBOL table."
  },
  "ORGANIZATION IS INDEXED": {
    "prefix": "INDEXED",
    "body": [
      "SELECT ${1:VSAM-FILE} ASSIGN TO ${2:VSMKSDS}",
      "\tORGANIZATION IS INDEXED",
      "\tACCESS IS DYNAMIC",
      "\tRECORD KEY IS ${3:VSAM-RECORD-KEY}"
    ],
    "description": "IS INDEXED defines a file entry as a VSAM KSDS (Indexed) Data Set in the ENVIRONMENT DIVISION'S SELECT/ASSIGN paragraph."
  },
  "ACCESS MODE IS INPUT": {
    "prefix": "INPUT",
    "body": [
      "SELECT ${1:CARPOOL} ASSIGN TO ${2:CARFILE}",
      "ORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL,LINE SEQUENTIAL|}",
      "ACCESS MODE IS INPUT."
    ],
    "description": "ENVIRONMENT DIVISION / INPUT-OUTPUT SECTION / FILE-CONTROL - File I/O mode that denotes if input is to be read from a file."
  },
  "INITIALIZE": {
    "prefix": "INITIALIZE",
    "body": ["INITIALIZE ${1:INSURED-NAME-ADDR}"],
    "description": "Use INITIALIZE instead of multiple MOVE statements to set a Group data structure to its initial values."
  },
  "INPUT-OUTPUT": {
    "prefix": "INPUT-OUTPUT",
    "body": ["INPUT-OUTPUT SECTION."],
    "description": "ENVIRONMENT DIVISION - The INPUT-OUTPUT SECTION of the ENVIRONMENT DIVISION contains FILE-CONTROL and I-O-CONTROL paragraphs. The contents of the INPUT-OUTPUT SECTION depend on specific file organization and access methods."
  },
  "INTO": {
    "prefix": "INTO",
    "body": ["INTO ${1:item}"],
    "description": "INSPECT CONVERTING"
  },
  "READ INTO": {
    "prefix": "INTO",
    "body": [
      "READ ${1:MY-CUSTOMER-FILE} INTO ${2:WE-CUSTOMER-REC}",
      "END-READ"
    ],
    "description": "READ INTO reads then copies records from FD buffers into WORKING-STORAGE data items."
  },
  "RETURN INTO": {
    "prefix": "RETURN INTO",
    "body": [
      "RETURN ${1:fileName} INTO TAB-ENTRY(${2:TAB-INDX})",
      "AT END MOVE \"${3:Y}\" TO ${4:WS-EOF-SORT}",
      "END-RETURN"
    ],
    "description": "RETURN INTO accesses a sorted file record and copies it into a WORKING-STORAGE data item."
  },
  "INSPECT TALLYING (COUNTER)": {
    "prefix": "INSPECT",
    "body": [
      "MOVE 0 TO ${1:COUNTER}",
      "INSPECT ${2:SOURCE} TALLYING ${1:COUNTER} FOR ${3|ALL SPACES,ALL ,CHARACTERS|}"
    ],
    "description": "INSPECT A TALLYING COUNTER FOR ..."
  },
  "INSTALLATION": {
    "prefix": "INSTALLATION",
    "body": ["INSTALLATION. ${1:machineName}"],
    "description": "IDENTIFICATION DIVISION - Use the optional INSTALLATION clause to uniquely name the z/OS system."
  },
  "INVALID": {
    "prefix": "INVALID",
    "body": ["INVALID ${1:impStat}"],
    "description": "INVALID"
  },
  "INVALID KEY (VSAM)": {
    "prefix": "INVALID KEY",
    "body": [
      "${1|READ,START,WRITE,REWRITE,DELETE|} ${2:VSAM-FILE}",
      "\tINVALID KEY GO TO ${3:999-VSAM-FILE-ERROR}",
      "END-READ."
    ],
    "description": "INVALID KEY can be used in VSAM KSDS and RRDS files for: READ, START, WRITE, REWRITE, and DELETE statements. The INVALID KEY imperative statement is given control if an I/O error occurs due to a defective VSAM file index key."
  },
  "INVALID KEY (QSAM)": {
    "prefix": "INVALID KEY",
    "body": [
      "WRITE ${1:QSAM-FILE}",
      "\tINVALID KEY GO TO ${2:999-DISK-FULL-ERROR}",
      "END-WRITE."
    ],
    "description": "For QSAM files, the INVALID KEY phrase can be used in WRITE requests. It is executed if you attempt to write to a I/O disk (VOL=SER) that is full."
  },
  "INVOKE": {
    "prefix": "INVOKE",
    "body": ["INVOKE ${1|id,CLASS,SELF,SUPER|} ${2|LIT,ID,NEW|}"],
    "description": "INVOKE"
  },
  "ACCESS IS": {
    "prefix": "IS",
    "body": ["ACCESS IS ${1|SEQUENTIAL,RANDOM,DYNAMIC|}"],
    "description": "File specifics with IS. (IS is optional)"
  },
  "USAGE IS": {
    "prefix": "USAGE IS",
    "body": [
      "01 ${1:VAR1} PIC ${2:X} USAGE IS ${3|DISPLAY,ALPHANUMERIC,SEPARATE,INDEX|}"
    ],
    "description": "Variable declarations with IS. (IS is optional)"
  },
  "IF x IS": {
    "prefix": "IF x IS",
    "body": [
      "IF ${1:VAR1} IS ${2|NUMERIC,ALPHABETIC,ALPHABETIC-LOWER,ALPHABETIC-UPPER,DBCS,KANJI,POSITIVE,NEGATIVE,ZERO|} THEN"
    ],
    "description": "Class conditional tests with IS."
  },
  "JNIENVPTR": {
    "prefix": "JNIENVPTR",
    "body": [
      "CALL \"${1:NEWFIELD}",
      "\tUSING BY VALUE JNIENVPTR",
      "\t\tADDRESS OF ${2:STRINGBUF}"
    ],
    "description": "JNIENVPTR is a COBOL special register that references the JNI pointer as declared in the JNI.cpy copybook. It is used when interfacing Java with COBOL. Special registers are reserved words that name storage areas generated by the compiler."
  },
  "JSON-CODE": {
    "prefix": "JSON-CODE",
    "body": ["01 JSON-CODE PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "JSON-CODE is a special register used to indicate that a JSON GENERATE or JSON PARSE statement executed successfully or that an exception occurred."
  },
  "JSON-STATUS": {
    "prefix": "JSON-STATUS",
    "body": ["01 JSON-STATUS PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "JSON-STATUS is a special register used to indicate that a JSON GENERATE or JSON PARSE statement executed successfully or that an exception occurred."
  },
  "JSON GENERATE FROM": {
    "prefix": "JSON GENERATE FROM",
    "body": ["JSON GENERATE ${1:id} FROM ${2:id}"],
    "description": "JSON GENERATE FROM"
  },
  "JSON PARSE INTO": {
    "prefix": "JSON PARSE INTO",
    "body": ["JSON PARSE ${1:id} INTO ${2:id}"],
    "description": "JSON PARSE INTO"
  },
  "JUST": {
    "prefix": "JUSTIFIED",
    "body": [
      "WORKING-STORAGE SECTION.",
      "\t01 ${1:VAR1} PIC X(40) JUSTIFIED RIGHT"
    ],
    "description": "The JUST/JUSTIFIED clause overrides standard positioning rules for receiving items of category alphabetic, alphanumeric, DBCS, or national."
  },
  "KANJI": {
    "prefix": "KANJI",
    "body": ["IF ${1:VAR1} IS KANJI", "\t${2:MOVE \"Y\" TO ${3:WS-KANJI-DOC}}"],
    "description": "One of several class conditional statements. Checks whether a variable entirely contains KANJI characters."
  },
  "ASCENDING KEY #1": {
    "prefix": "ASCENDING KEY IS",
    "body": [
      "01 ${1:TABLE-ENTRIES}",
      "\t05 ${2:TAB-COLM3} OCCURS ${3:100} TIMES",
      "\tASCENDING KEY IS ${4:TAB-KEY4} INDEXED BY ${5:TAB-COLM3-IDX}.",
      "\t\t20 ${4:TAB-KEY4} PIC X(5)."
    ],
    "description": "ASCENDING KEY in a table OCCURS clause allows you to use a COBOL SEARCH ALL construct."
  },
  "ASCENDING KEY #2": {
    "prefix": "ASCENDING KEY IS",
    "body": [
      "15 ${1:TABLE-ENTRY3} OCCURS ${2:5} TIMES",
      "ASCENDING KEY IS ${3:KEY1}",
      "INDEXED BY ${4:TE3-INDEX}.",
      "20 ${5:KEY1} PIC X(5)."
    ],
    "description": "ASCENDING KEY in a table OCCURS clause allows you to use a COBOL SEARCH ALL construct."
  },
  "RECORD KEY": {
    "prefix": "KEY",
    "body": [
      "SELECT ${1:VSAM-FILE} ASSIGN TO ${2:VSMKSDS}",
      "RECORD KEY IS ${3:VSAMFILE-KEY}"
    ],
    "description": "ENVIRONMENT DIVISION / FILE-CONTROL - RECORD KEY declares a field that you define in the FILE SECTION to be used to search the indexed/VSAM data. The same technique can be used for SORT Files."
  },
  "KEY IS": {
    "prefix": "KEY IS",
    "body": ["KEY IS ${1:item}"],
    "description": "KEY IS"
  },
  "LABEL RECORDS": {
    "prefix": "LABEL RECORDS",
    "body": ["FD ${1:inputFile}", "LABEL RECORDS ARE STANDARD"],
    "description": "DATA DIVISION / FILE SECTION - For QSAM files, LABEL RECORDS declares the presence or absence of labels used to identify DASD volumes for uncataloged files. For VSAM files LABEL RECORDS is syntax checked but ignored."
  },
  "LEADING BY": {
    "prefix": "LEADING BY",
    "body": ["LEADING ${1:id} BY ${2:id}"],
    "description": "LEADING BY"
  },
  "LEADING": {
    "prefix": "LEADING",
    "body": ["01 ${1:VAR-NUM} ${2:PIC S9999} DISPLAY SIGN LEADING"],
    "description": "SIGN LEADING/TRAILING declares the position of the operational sign for a numeric variable."
  },
  "LEFT": {
    "prefix": "LEFT",
    "body": [
      "01 ${1:GROUP-VAR}.",
      "\t05 ${2:NUM-BINARY-VAR} PIC S9(4) COMP SYNC LEFT."
    ],
    "description": "LEFT Specifies that an elementary COBOL variable is to be positioned in main storage so that byte one begins at the left word boundary. Note that this is an efficiency coding specification."
  },
  "LENGTH": {
    "prefix": "LENGTH",
    "body": [
      "MOVE ${1:INS-ADDR} TO ${2:OUTPUT-REC}(1:FUNCTION LENGTH(${3:CUST-NAME}))."
    ],
    "description": "Find and use the LENGTH of COBOL variables and group structures."
  },
  "LESS": {
    "prefix": "LESS",
    "body": [
      "IF ${1:VAR1} LESS THAN ${2:VAR2} THEN",
      "\t${3:ifTrue}",
      "END-IF."
    ],
    "description": "LESS is a general comparison operator. Treated like the algebraic \"<\" operator."
  },
  "LINEAGE": {
    "prefix": "LINEAGE",
    "body": ["FD ${1:FILENAME}", "\tLINEAGE ${2:50}", "\t$0"],
    "description": "DATA DIVISION - The LINEAGE clause of a FD entry controls the size and number of lines of a printed page."
  },
  "WRITE LINE": {
    "prefix": "LINES",
    "body": [
      "WRITE ${1:PRINT-REC} ${2|BEFORE,AFTER|} ADVANCING ${3:numLiteral} LINES."
    ],
    "description": "Use LINE to control the number of blank lines output for a report file."
  },
  "LINE SEQUENTIAL": {
    "prefix": "LINE SEQUENTIAL",
    "body": [
      "\tSELECT ${1:FILE-1} ASSIGN TO ${2:EXTFILE1}",
      "\tORGANIZATION IS LINE SEQUENTIAL"
    ],
    "description": "ENVIRONMENT DIVISION - LINE SEQUENTIAL defines an input/output file as a LINE SEQUENTIAL file, typically Unix or PC."
  },
  "LOC": {
    "prefix": "LOC",
    "body": ["LOC ${1:integer}"],
    "description": "LOC"
  },
  "LOCAL-STORAGE": {
    "prefix": "LOCAL-STORAGE",
    "body": ["LOCAL-STORAGE SECTION."],
    "description": "LOCAL-STORAGE defines variables that are allocated and freed on a per-program invocation basis. Every program invocation reallocates the LOCAL-STORAGE variables and resets variable values to their declared initial values."
  },
  "CLOSE x WITH LOCK": {
    "prefix": "LOCK",
    "body": ["CLOSE ${1:filename} WITH LOCK."],
    "description": "CLOSE WITH LOCK ensures that the file cannot be opened again while the program is executing."
  },
  "READ LOW-VALUE": {
    "prefix": "LOW-VALUE",
    "body": ["READ ${1:IN-FILE} AT END MOVE LOW-VALUES TO ${2:INPUT-REC}."],
    "description": "For Alphanumeric fields - LOW-VALUE/LOW-VALUES equates to binary (Hex) 00, the lowest EBCDIC collating sequence value."
  },
  "MOVE LOW-VALUE": {
    "prefix": "LOW-VALUE",
    "body": ["MOVE LOW-VALUES TO ${1:VAR1}."],
    "description": "For Alphanumeric fields - LOW-VALUE/LOW-VALUES equates to binary (Hex) 00, the lowest EBCDIC collating sequence value."
  },
  "IF LOW-VALUE": {
    "prefix": "LOW-VALUE",
    "body": [
      "IF ${1:VAR1} = LOW-VALUES",
      "\t${2:MOVE SPACES TO ${1:VAR}}",
      "END-IF."
    ],
    "description": "For Alphanumeric fields - LOW-VALUE/LOW-VALUES equates to binary (Hex) 00, the lowest EBCDIC collating sequence value."
  },
  "LINKAGE SECTION ": {
    "prefix": "LINKAGE SECTION",
    "body": ["LINKAGE SECTION.", "$0"],
    "description": "LINKAGE SECTION."
  },
  "MERGE": {
    "prefix": "MERGE",
    "body": ["MERGE ${1:fileName} ${2:snipasc|DESC} ${3:dataname}"],
    "description": "MERGE FILENAME"
  },
  "MERGE USING": {
    "prefix": "MERGE USING",
    "body": [
      "MERGE ${1:fileName} ${2:snipasc|DESC} ${3:dataname} USING ${4:fileName} ${5:fileName}"
    ],
    "description": "MERGE USING"
  },
  "MERGE CORR": {
    "prefix": "MERGE CORR",
    "body": ["MOVE CORR ${1:id}"],
    "description": "MERGE USING"
  },
  "MERGE ASCENDING": {
    "prefix": "MERGE ASCENDING",
    "body": ["MERGE ${1:fileName} ON ASCENDING ${2:file-section-variable}"],
    "description": "The Merge statement fuses two or more identially sorted files on one or more variable-keys and makes the merged records available to an OUTPUT PROCEDURE or output file."
  },
  "ACCESS MODE": {
    "prefix": "ACCESS MODE",
    "body": [
      "FD ${1:FILENAME}",
      "LABEL RECORDS ARE STANDARD",
      "BLOCK CONTAINS ${2:0}",
      "ACCESS MODE IS ${3|SEQUENTIAL,INDEXED,RELATIVE,LINE SEQUENTIAL|}",
      "\tRECORD CONTAINS ${4:numLiteral} CHARACTERS"
    ],
    "description": "ACCESS MODE defines how records are made available for processing. If ACCESS MODE is not defined, the default is SEQUENTIAL."
  },
  "RECORDING MODE": {
    "prefix": "RECORDING MODE",
    "body": [
      "FD ${1:FILENAME}",
      "LABEL RECORDS ARE STANDARD",
      "BLOCK CONTAINS ${2:0}",
      "RECORDING MODE IS ${3|F,V,U,S|}",
      "\tRECORD CONTAINS ${4:numLiteral} CHARACTERS"
    ],
    "description": "FILE SECTION - RECORDING MODE specifies the physical format of records in a QSAM file: F (fixed), V (variable), U (fixed or variable), S (spanned)"
  },
  "DEBUGGING MODE": {
    "prefix": "DEBUGGING MODE",
    "body": ["SOURCE-COMPUTER WITH DEBUGGING MODE."],
    "description": "WITH DEBUGGING MODE activates a compile-switch for debugging lines in the program."
  },
  "MORE-LABELS": {
    "prefix": "MORE-LABELS",
    "body": ["GO TO MORE-LABELS"],
    "description": "GO TO MORE-LABELS statement is specified only in a COBOL LABEL DECLARATIVE statement."
  },
  "MOVE CORRESPONDING": {
    "prefix": "MOVE CORRESPONDING",
    "body": ["MOVE CORRESPONDING ${1:group-1} TO ${2:group-2}"],
    "description": "After the above MOVE CORRESPONDING statement, all values in like-named-variables will be copied from GROUP-1 to GROUP-2."
  },
  "MOVE": {
    "prefix": "MOVE",
    "body": ["MOVE ${1:VAR1} TO ${2:VAR2}"],
    "description": "MOVE copies data from one variable to one or more other variables. Note that storage data and Figurative Constants (SPACES, HIGH-VALUES, LOW-VALUES, etc.) can be moved into variables."
  },
  "MOVE TO": {
    "prefix": "MOVE TO",
    "body": ["MOVE ${1:id} TO ${2:id}"],
    "description": "MOVE"
  },
  "MULTIPLY BY": {
    "prefix": "MULTIPLY BY",
    "body": ["MULTIPLY ${1:id} BY ${2:id} ROUNDED"],
    "description": "MULTIPLY"
  },
  "MULTIPLY a BY b GIVING c": {
    "prefix": "MULTIPLY",
    "body": ["MULTIPLY ${1:A} BY ${2:B} GIVING ${3:C} ROUNDED"],
    "description": "MULTIPLY a BY b GIVING c"
  },
  "MULTIPLY a BY b GIVING c ON SIZE ERROR": {
    "prefix": "MULTIPLY",
    "body": [
      "MULTIPLY ${1:A} BY ${2:B} GIVING ${3:C} ROUNDED",
      "ON SIZE ERROR ${4:imperative_statement}",
      "END-MULTIPLY."
    ],
    "description": "If ON SIZE ERROR is specified and a size error condition occurs (typically truncation in the product) the error result is not placed in the product and the imperative statement in the ON SIZE ERROR phrase is executed."
  },
  "NAME IS": {
    "prefix": "NAME IS",
    "body": ["NAME ${1:id} IS ${2:LIT}"],
    "description": "NAME ID IS LIT"
  },
  "NAMESPACE": {
    "prefix": "NAMESPACE",
    "body": ["NAME ${1:id} IS ${2:LIT}"],
    "description": "NAMESPACE ITEM *"
  },
  "NAMESPACE-prefix": {
    "prefix": "NAMESPACE-prefix",
    "body": ["NAMESPACE ${1:item}"],
    "description": "NAMESPACE-prefix ITEM"
  },
  "NATIONAL-EDITED #1": {
    "prefix": "NATIONAL-EDITED",
    "body": [
      "01 ${1:ORIG-CUSTOMER-NAME} GROUP-USAGE NATIONAL",
      "\t05 ${2:SURNAME} PIC N(${3:17})."
    ],
    "description": "WORKING-STORAGE SECTION - NATIONAL/NATIONAL-EDITED data items are variables whose content is represented in UTF-16 (often referred to as Unicode)."
  },
  "NATIONAL-EDITED #2": {
    "prefix": "NATIONAL-EDITED",
    "body": ["INITIALIZE ${1:VAR1} REPLACING NATIONAL DATA BY ${2:VAR2}"],
    "description": "PROCEDURE DIVISION - NATIONAL/NATIONAL-EDITED data (or data items within a group field) are replaced by the same-named variables in VAR-2 in the given example."
  },
  "NATIVE": {
    "prefix": "NATIVE",
    "body": ["01 ${1:VAR-BIN} PIC S9(4) COMPUTATIONAL USAGE NATIVE."],
    "description": "NATIVE is syntax checked, but has no effect on program execution."
  },
  "NEXT SENTENCE": {
    "prefix": "NEXT SENTENCE",
    "body": ["IF ${1:statement}", "\t$0", "ELSE", "\tNEXT SENTENCE", "END-IF"],
    "description": "NEXT SENTENCE transfers control to the next sequential instruction following the closest period (separator)."
  },
  "NEXT RECORD": {
    "prefix": "NEXT RECORD",
    "body": [
      "READ ${1:CUSTOEMR-FILE} NEXT RECORD INTO ${2:WS-CUSTOMER-REC}",
      "\tAT END MOVE \"Y\" TO ${3:WS-NO-MORE-CUST-RECS}",
      "END-IF."
    ],
    "description": "NEXT RECORD is a phrase that reads the next record from an input file. NEXT is optional for QSAM files, but you must specify NEXT RECORD to retrieve records sequentially from a VSAM file."
  },
  "NO ADVANCING": {
    "prefix": "NO ADVANCING",
    "body": ["DISPLAY \"${1:ERROR IN OPENING FILE}\" WITH NO ADVANCING."],
    "description": "When used, the positioning of the output device will not be changed."
  },
  "NO REWIND": {
    "prefix": "NO REWIND",
    "body": ["${1|OPEN INPUT,CLOSE|} ${2:filename} WITH NO REWIND."],
    "description": "NO REWIND applies only to LINE SEQUENTIAL and QSAM tape files.  Specifically, with NO REWIND, OPEN filename must be positioned at its beginning record."
  },
  "IF var NOT x": {
    "prefix": "NOT",
    "body": [
      "IF ${1:variable-1} IS NOT ${2:statement} THEN",
      "\t$0",
      "END-IF."
    ],
    "description": "NOT is a true/false test. Testing true if the comparison fails."
  },
  "NOT ON SIZE ERROR": {
    "prefix": "NOT ON SIZE ERROR",
    "body": [
      "SUBTRACT ${1:VAR-2} FROM ${2:VAR-1} GIVING ${3:VAR-3}",
      "NOT ON SIZE ERROR ${4:MOVE ZEROS TO VAR-4}"
    ],
    "description": "NOT is a true/false test. Testing true if the comparison fails. In the snippet, if there is no numeric exception in the subtract, zeros are moved to VAR-4."
  },
  "NOT INVALID": {
    "prefix": "NAMESPACE-prefix",
    "body": ["NOT INVALID ${1:impStat}"],
    "description": "NOT INVALID ITEM"
  },
  "NULL": {
    "prefix": "NULL",
    "body": [
      "IF ${1:PTR-VAR} IS NULL",
      "\tSET ${1:PTR-VAR} TO ${2|identifier,ADDRESS OF identifier,NULL|}",
      "END-IF."
    ],
    "description": "NULL which has the value of zero, is a data type used with datatypes of: POINTER, PROCEDURE-POINTER, FUNCTION-POINTER, OBJECT REFERENCE, or the ADDRESS OF a special register."
  },
  "NUMERIC": {
    "prefix": "NUMERIC",
    "body": ["IF ${1:VAR-COMP-3} IS NUMERIC", "\t$0", "END-IF."],
    "description": "IF NUMERIC is a conditional class test which can be applied to variable types: DISPLAY, NATIONAL, COMPUTATIONAL-3, or PACKED-DECIMAL."
  },
  "NUMERIC-EDITED": {
    "prefix": "NUMERIC-EDITED",
    "body": [
      "INITIALIZE ${1:VAR1} REPLACING NUMERIC-EDITED DATA BY ${2:literal or variable}",
      "END-INITIALIZE."
    ],
    "description": "NUMERIC-EDITED => Numeric data items with insertion characters."
  },
  "OBJECT-COMPUTER": {
    "prefix": "OBJECT-COMPUTER",
    "body": ["OBJECT-COMPUTER ${1:COMPUTER-NAME}."],
    "description": "ENVIRONMENT DIVISION - The OBJECT-COMPUTER paragraph details the mainframe for which the compiled object program is run on."
  },
  "OBJECT-REFERENCE": {
    "prefix": "OBJECT-REFERENCE",
    "body": ["01 ${1:VAR-OBJ-REF} PIC X(36) USAGE OBJECT-REFERENCE."],
    "description": "An OBJECT-REFERENCE data item is a 4 or 8 byte (depending on your z/OS system) that references valid objects."
  },
  "OCCURS": {
    "prefix": "OCCURS",
    "body": [
      "01 ${1:TABLE-GROUP-NAME}.",
      "\t05 ${2:TABLE-ROW-NAME} OCCURS ${3:5} TIMES."
    ],
    "description": "OCCURS is used to code a table by defining a number (N) of repeated subordinate rows."
  },
  "OCCURS DEPENDING ON": {
    "prefix": "OCCURS DEPENDING ON",
    "body": [
      "01 ${1:TABLE-GROUP-NAME}.",
      "\t05 ${2:TABLE-ROW-SIZE} PIC 9(4).",
      "\t05 ${3:FIELD-2} OCCURS ${4:1} TO ${5:5} TIMES",
      "\t\tDEPENDING ON ${2:TABLE-ROW-SIZE} ${6:arrayEntryCountDefinition}"
    ],
    "description": "OCCURS DEPENDING ON is used to code a table where you do not know how many rows are in the table."
  },
  "MOVE x OF y TO": {
    "prefix": "OF",
    "body": [
      "MOVE ${1:CUSTOMER-NO} OF ${2:CUST-IN} TO ${3:CUSTOMER-NO} OF ${4:CUST-OUT}."
    ],
    "description": "OF (qualification) allows you to uniquely specify a variable by referencing higher-level variable-names in a struction."
  },
  "SET ADDRESS OF": {
    "prefix": "OF",
    "body": ["SET ADDRESS OF ${1:VAR-POINTER-1} TO ${2:VAR-POINTER-2}."],
    "description": "ADDRESS OF is a COBOL special register to reference the address of a data item in the LINKAGE SECTION, LOCAL-STORAGE SECTION, or WORKING-STORAGE SECTION."
  },
  "INLINE OFF": {
    "prefix": "OFF",
    "body": ["INLINE OFF"],
    "description": "This COBOL directive OFF prevents the compiler from inlining procedures referenced by PERFORM statements."
  },
  "RECORDS ARE OMITTED": {
    "prefix": "OMITTED",
    "body": [
      "SELECT ${1:TAPE-FILE} ASSIGN TO ${2:TAPEFLXT}",
      "LABEL RECORDS ARE OMITTED"
    ],
    "description": "Used for Tape files without z/OS data set LABELS."
  },
  "NAME IS OMITTED": {
    "prefix": "OMITTED",
    "body": ["JSON PARSE ${1:VAR-1} INTO ${2:VAR-2} NAME IS OMITTED."],
    "description": "Can use the NAME IS OMITTED phrase to parse an anonymous JSON array in addition to an anonymous JSON object."
  },
  "DEPENDING ON": {
    "prefix": "ON",
    "body": [
      "01 ${1:DATA-TAB}.",
      "\t05 ${2:MSG} OCCURS ${3:0} TO ${4:5} DEPENDING ON ${5:TBL-ROW-SIZE}.",
      "\t\t10 ${6:MSG-VERSION} USAGE COMP-1.",
      "\t\t10 ${7:USER-ID-IN} PIC 9999 USAGE DISPLAY.",
      "\t\t10 ${8:TBL-ROW-SIZE} PIC 9(4) COMP.",
      "\t\t10 ${9:MSG-TXT} PIC X(32)."
    ],
    "description": "ON is used as part of a dynamic table declaration."
  },
  "SET ptr ON": {
    "prefix": "ON",
    "body": ["SET ${1:WS-FILE-PTR} ON."],
    "description": "ON is used to set a pointer or 88-conditional to True."
  },
  "ON SIZE ERROR": {
    "prefix": "ON SIZE ERROR",
    "body": [
      "MULTIPLY ${1:VAR-1} BY ${2:VAR-2} GIVING ${3:VAR-3}",
      "\tON SIZE ERROR GO TO ${4:ARITH-PROBLEM}",
      "END-MULTIPLY."
    ],
    "description": "ON is used to code: ON SIZE ERROR, ON OVERFLOW and ON EXCEPTION error and exception trapping phrases."
  },
  "OPEN EXTEND": {
    "prefix": "OPEN EXTEND",
    "body": ["OPEN EXTEND ${1:fileName}"],
    "description": "OPEN EXTEND FILENAME"
  },
  "OPEN I-O": {
    "prefix": "OPEN I-O",
    "body": ["OPEN I-O ${1:fileName}"],
    "description": "OPEN I/O FILENAME."
  },
  "OPEN INPUT": {
    "prefix": "OPEN INPUT",
    "body": ["OPEN INPUT ${1:fileName}${2|., REVERSED., WITH NO REWIND.|}"],
    "description": "OPEN INPUT initiates the process of reading files. Note that REVERSED and WITH NO REWIND are optional clauses."
  },
  "OPEN OUTPUT": {
    "prefix": "OPEN OUTPUT",
    "body": ["OPEN OUTPUT ${1:fileName}${2|., WITH NO REWIND.|}"],
    "description": "OPEN OUTPUT initiates the process of writing files. Note that NO REWIND is optional."
  },
  "OPTIONAL": {
    "prefix": "OPTIONAL",
    "body": ["SELECT OPTIONAL ${1:filename}", "ASSIGN TO ${2:EXTFILE}"],
    "description": "If SELECT OPTIONAL is specified in the file-control entry for this file, and the file is not available at runtime, execution of the first READ statement causes an at-end condition rather than an ABEND. This applies to QSAM and VSAM files opened for INPUT, I-O, or EXTEND."
  },
  "If x OR y": {
    "prefix": "OR",
    "body": [
      "IF ${1:statement-1} OR ${2:statement-2} THEN",
      "\t${3:ifEitherIsTrue}",
      "END-IF."
    ],
    "description": "A logical comparison operator. The truth value of OR is true when either or both conditions are met."
  },
  "WHEN x OR y": {
    "prefix": "WHEN x OR y",
    "body": [
      "EVALUATE ${1:PATIENT-CODE}",
      "\tWHEN = \"${2:I}\" OR \"${3:E}\"",
      "\t\t${4:statementWhenIsTrue}",
      "END-IF."
    ],
    "description": "A logical comparison operator that is part of an EVALUATE statement. The truth value of OR is true when either or both conditions are met."
  },
  "DUPLICATES IN ORDER": {
    "prefix": "ORDER",
    "body": [
      "SORT ${1:varOrTable} ON ${2|ASCENDING,DESCENDING|} ${3:sort-var-key}",
      "DUPLICATES IN ORDER."
    ],
    "description": "If duplicate records are found, by coding DUPLICATES IN ORDER z/OS will maintain the physical order. Without this phrase, the sorting of duplicate records is undefined."
  },
  "ORGANIZATION (QSAM)": {
    "prefix": "ORGANIZATION",
    "body": [
      "SELECT ${1:rptfil} ASSIGN TO ${2:rptfilDD}",
      "\tORGANIZATION IS SEQUENTIAL.",
      "$0"
    ],
    "description": "QSAM file accessed sequentially (one record after the next)."
  },
  "ORGANIZATION (VSAM)": {
    "prefix": "ORGANIZATION",
    "body": [
      "SELECT ${1:rptfil} ASSIGN TO ${2:rptfilDD}",
      "\tORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL|}.",
      "\tACCESS MODE IS ${4|SEQUENTIAL,RANDOM,DYNAMIC|} RECORD KEY IS ${5:key1}.",
      "$0"
    ],
    "description": "VSAM file ORGANIZATION clause for a VSAM file accessed through the file's index (key1)."
  },
  "OTHER": {
    "prefix": "OTHER",
    "body": [
      "EVALUATE ${1:VAR-1}",
      "\tWHEN ${2:statement}",
      "\t\t${3:doThisWhenTrue}",
      "\tWHEN OTHER",
      "\t\t${4:defaultToThis}",
      "END-EVALUATE."
    ],
    "description": "In an EVALUATE statement if no WHEN phrase is selected and WHEN OTHER is specified, execution continues with the OTHER statement."
  },
  "OUTPUT": {
    "prefix": "OUTPUT",
    "body": ["OPEN OUTPUT ${1:fileName}${2|., WITH NO REWIND.|}"],
    "description": "OUTPUT FILENAME"
  },
  "OUTPUT PROCEDURE": {
    "prefix": "OUTPUT PROCEDURE",
    "body": [
      "${1:000-MAIN}.",
      "SORT ${2:IN-FILE} ON ${3|ASCENDING,DESCENDING|} KEY ${4:IN-SORT-KEY}",
      "\tINPUT PROCEDURE IS ${5:PATIENT-EDIT-INPUT}",
      "\tOUTPUT PROCEDURE IS ${6:procName}."
    ],
    "description": "PROCEDURE DIVISION - In a SORT or MERGE statement OUTPUT PROCEDURE specifies the name of a COBOL SECTION or paragraph that selects and/or modifies output records from the SORT/MERGE operation."
  },
  "ON OVERFLOW GO TO (Unstring Statement)": {
    "prefix": "OVERFLOW",
    "body": [
      "UNSTRING ${1:PATIENT-RCD}",
      "\tDELIMITED BY ${2:statement}",
      "\tINTO ${3:PATIENT-NAME}",
      "\tON OVERFLOW GO TO ${4:UNSTRING-OVERFLOW}",
      "END-UNSTRING."
    ],
    "description": "ON OVERFLOW with UNSTRING allows you to trap text-parsing errors during runtime. After ON OVERFLOW you can code any imperative statement."
  },
  "ON OVERFLOW GO TO (String Statement)": {
    "prefix": "OVERFLOW",
    "body": [
      "STRING ${1:PATIENT-NO SPACE PATIENT-NAME INV-NO SPACE DATE-PROCESS SPACE}",
      "\tDELIMITED BY ${2:SIZE}",
      "\tINTO ${3:WS-PATIENT-RPT-LINE}",
      "\tON OVERFLOW GO TO ${4:STRING-OVERFLOW}",
      "END-STRING."
    ],
    "description": "ON OVERFLOW with STRING allows you to trap text-parsing errors during runtime. After ON OVERFLOW you can code any imperative statement."
  },
  "ON OVERFLOW GO TO (Call Statement)": {
    "prefix": "OVERFLOW",
    "body": [
      "CALL \"${1:progName}\"",
      "\tON OVERFLOW GO TO ${1:CALL-PGM-OVERFLOW}",
      "END-CALL."
    ],
    "description": "ON OVERFLOW with CALL statements allows you to trap runtime called program name errors. Without ON OVERFLOW the program will ABEND. After ON OVERFLOW you can code any imperative statement."
  },
  "PACKED-DECIMAL": {
    "prefix": "PACKED-DECIMAL",
    "body": ["01 ${1:VAR-PACKED-NUM-DATA} PIC S9(4) PACKED-DECIMAL."],
    "description": "PACKED-DECIMAL variables (internally) are stored with two digits for each character position, except for the trailing character position, which is occupied by the low-order digit and the variable's sign. PACKED-DECIMAL is identical to COMP-3/COMPUTATIONAL-3."
  },
  "PADDING CHARACTER IS": {
    "prefix": "PADDING CHARACTER IS",
    "body": [
      "SELECT ${1:INTERNAL-FILENAME} ASSIGN ${2:EXTFILE}",
      "BLOCK CONTAINS ${3:170}",
      "PADDING CHARACTER IS \"${4:B}\"."
    ],
    "description": "PADDING CHARACTER specifies a character, or variable defined in WORKING-STORAGE, to be used for record-blocking-factor padding on sequential files. (That is, filling out a BLOCK of records. BLOCK is the unit of file I/O between DFSMS and your program's DATA DIVISION.)"
  },
  "PARSE": {
    "prefix": "PARSE",
    "body": ["PARSE ${1:item}"],
    "description": "PARSE ITEM"
  },
  "PERFORM": {
    "prefix": "PERFORM UNTIL",
    "body": [
      "MOVE ${1:1} TO SUB.",
      "PERFORM UNTIL SUB > ${2:100}",
      "\t${3:codeHere}",
      "ADD +1 TO SUB",
      "END-PERFORM."
    ],
    "description": "PERFORM PARAGRAPH X TIMES"
  },
  "PERFORM TIMES": {
    "prefix": "PERFORM TIMES",
    "body": ["PERFORM ${1:procName} ${2:id|int} TIMES"],
    "description": "PERFORM TIMES PROCEDURE NAME X TIMES"
  },
  "PERFORM THRU": {
    "prefix": "PERFORM THRU",
    "body": [
      "PERFORM ${1:100-OPEN-FILES}",
      "\tTHRU ${2:100-FILES-EXIT}",
      "END-PERFORM."
    ],
    "description": "PERFORM THRU transfers control to one or more paragraphs or SECTIONS and returns control to the next sequential executable statement after the THRU paragraph or SECTION finishes."
  },
  "PERFORM-END-PERFORM": {
    "prefix": "PERFORM",
    "body": ["PERFORM ${1}", "\t${2}", "END-PERFORM", "${0}"],
    "description": "PERFORM .. END-PERFORM"
  },
  "PERFORM VARYING": {
    "prefix": "PERFORM",
    "body": [
      "PERFORM ${1:paragraph-name} VARYING ${2:field-1}",
      " FROM ${3:value-1} BY ${4:value-2}",
      " UNTIL ${5:condition}",
      "$0"
    ],
    "description": "INLINE PERFORM VARYING"
  },
  "PICTURE": {
    "prefix": "PICTURE",
    "body": ["01 ${1:VAR-NAME} PIC ${2:X(111) VALUE SPACE}."],
    "description": "The reserved word PICTURE or PIC describes a data variable to the COBOL compiler (and program)."
  },
  "POINTER": {
    "prefix": "POINTER",
    "body": ["01 ${1:WS-JAVA-NI-VAR} USAGE POINTER"],
    "description": "POINTER defines a variable as a 4 or 8 byte field. This is dependent on the LP(nn) Compiler directive, which contains the address of a variable, instead of its contents."
  },
  "POINTER-32": {
    "prefix": "POINTER-32",
    "body": ["01 ${1:WS-JAVA-NI-VAR} USAGE POINTER-32"],
    "description": "POINTER-32 defines a variable as a 4 byte field. This is independent of the LP(nn) Compiler directive, which contains the address of a variable, instead of its contents."
  },
  "POSITIVE": {
    "prefix": "POSITIVE",
    "body": ["IF ${1:CONDITION} IS POSITIVE", "\t$0", "END-IF."],
    "description": "POSITIVE is a \"sign condition\" used to determine whether the algebraic value of a numeric variable is greater than zero."
  },
  "PROCEDURE DIVISION": {
    "prefix": "PROCEDURE-DIVISION",
    "body": ["PROCEDURE DIVISION.", "$0"],
    "description": "PROCEDURE DIVISION"
  },
  "PROCEDURE DIVISION USING": {
    "prefix": "PROCEDURE DIVISION USING",
    "body": [
      "DATA DIVISION.",
      "LINKAGE SECTION.",
      "01 ${1:EXTERNAL-DATA} ${2:PIC X(872)}.",
      "PROCEDURE DIVISION USING ${1:EXTERNAL-DATA}."
    ],
    "description": "PROCEDURE DIVISION USING allows you reference data being passed from a calling module to your program through the LINKAGE SECTION."
  },
  "PROCEDURE IS": {
    "prefix": "PROCEDURE IS",
    "body": [
      "SORT ${1:fileName}",
      "${2|INPUT,OUTPUT|} PROCEDURE IS ${3:100-RECORD-SEL} SECTION"
    ],
    "description": "PROCEDURE DIVISION - The INPUT and OUTPUT PROCEDUREs are used to select specific records that will be released to a SORT and process records returned from a SORT."
  },
  "PROCEDURE-POINTER": {
    "prefix": "PROCEDURE-POINTER",
    "body": ["01 ${1:LE-UTILITY} USAGE IS PROCEDURE-POINTER."],
    "description": "A PROCEDURE-POINTER is a variable which contains the address of a procedure \"entry point\". PROCEDURE-POINTER variables are often used to CALL z/OS LE (Language Environment) utilities."
  },
  "USE FOR DEBUGGING ON ALL PROCEDURES": {
    "prefix": "PROCEDURES",
    "body": ["USE FOR DEBUGGING ON ALL PROCEDURES"],
    "description": "A USE FOR DEBUGGING keyword, which you can specify as ALL PROCEDURES once in a program."
  },
  "PROCESSING": {
    "prefix": "PROCESSING",
    "body": [
      "XML PARSE ${1:intentifier-1} RETURNING NATIONAL",
      "VALIDATING WITH ${2:indentifier-2} FILE ${3:xml-schema-name-1}",
      "PROCESSING PROCEDURE IS ${4:procedure-name-1}."
    ],
    "description": "XML PARSE translates an XML document into individual pieces, then passes each piece to a user-written COBOL paragraph."
  },
  "END PROGRAM": {
    "prefix": "END PROGRAM",
    "body": ["END PROGRAM ${TM_FILENAME/(.*)\\..+$/${1:/UPCASE}/}."],
    "description": "END PROGRAM designates the end of a called module and returns control to the calling module. The program name must be identical to its PROGRAM-ID."
  },
  "PROGRAM-ID": {
    "prefix": "PROGRAM-ID.",
    "body": ["PROGRAM-ID. ${1:${TM_FILENAME/(.*)\\..+$/${1:/UPCASE}/}}.", "$0"],
    "description": "IDENTIFICATION DIVISION - PROGRAM-ID provides a unique name for a COBOL program."
  },
  "PROPERTY": {
    "prefix": "PROPERTY",
    "body": [
      "01 ${1:_PROP} ${2:BINARY-LONG} PRIVATE.",
      "METHOD-ID. GET PROPERTY #${3:PROP}.",
      "PROCEDURE DIVISION RETURNING RET AS ${2:BINARY-LONG}.",
      "\tSET RET TO ${1:_PROP}",
      "END METHOD.",
      "METHOD-ID. SET PROPERTY #${3:PROP}.",
      "PROCEDURE DIVISION USING BY VALUE VAL AS ${2:BINARY-LONG}.",
      "\tSET ${1:_PROP} TO 0",
      "END METHOD.",
      ""
    ],
    "description": "SET/GET PROPERTY"
  },
  "QUOTE": {
    "prefix": "QUOTE",
    "body": ["01 ${1:WS-QUOTE-FIELD} PIC ${2:X(01)} VALUE QUOTES."],
    "description": "QUOTE/QUOTES is a figurative constant. It can also be used in a comparison or MOVE statement."
  },
  "ACCESS MODE IS RANDOM": {
    "prefix": "RANDOM",
    "body": [
      "SELECT ${1:RRDS-FILE} ASSIGN TO ${2:VSMRRDS}",
      "ACCESS MODE IS RANDOM."
    ],
    "description": "The RANDOM intrinsic function generates a random number between 0 and 1"
  },
  "READ (QSAM)": {
    "prefix": "READ",
    "body": [
      "READ ${1:QSAM-File} INTO ${2:WS-Record-Layout}",
      "AT END MOVE \"${3:Y}\" TO ${4:WS-EOF-Switch}"
    ],
    "description": "For QSAM file access, the READ statement makes the next record from a sequential file available to the program. In the given example, READ includes the INTO modifier, which moves the record from the I/O buffer into program WORKING-STORAGE, and the AT END modifier which forces z/OS to signal the program that the last record in the file has been read."
  },
  "READ (VSAM)": {
    "prefix": "READ",
    "body": [
      "READ ${1:VSAM-File} INTO ${2:WS-Record-Layout}",
      "KEY IS ${3:Key-field}",
      "INVALID KEY ${4:imperative-statement}"
    ],
    "description": "For VSAM (keyed) file access, the READ statement makes a specific record from an indexed file available to the program. In the above example, READ includes the INTO modifier, which moves the record from the I/O buffer into program WORKING-STORAGE, and the INVALID KEY modifier which forces z/OS to signal the program that no record was found in the VSAM file that matches the data in the key field."
  },
  "RECORD CONTAINS": {
    "prefix": "RECORD",
    "body": [
      "FD ${1:CARPOOL}",
      "\tLABEL RECORDS STANDARD",
      "\tRECORD CONTAINS ${2:80} CHARACTERS."
    ],
    "description": "DATA DIVISION / FILE SECTION - As part of a COBOL FD, RECORD (singular) is used with the RECORD CONTAINS clause, which defines the size (in bytes) of each logical record in the file."
  },
  "RECORD KEY IS": {
    "prefix": "RECORD",
    "body": [
      "SELECT ${1:VSAM-PATIENT-FILE} ASSIGN TO ${2:PATIENTS}",
      "\tORGANIZATION IS INDEXED ACCESS IS RANDOM",
      "\tRECORD KEY IS ${3:COMMUTER-KEY}",
      "\tFILE STATUS IS ${4:PAT-FILESTATUS}."
    ],
    "description": "As part of a VSAM SELECT/ASSIGN, RECORD (singular) is used in a RECORD KEY IS clause to describe the indexed access of a specific record in the given file."
  },
  "RECORDING": {
    "prefix": "RECORDING",
    "body": [
      "FD ${1:CARPOOL}",
      "\tLABEL RECORDS STANDARD",
      "\tRECORDING MODE IS ${2|F,FB,V,U,S|}",
      "\tRECORD CONTAINS ${3:80} CHARACTERS."
    ],
    "description": "DATA DIVISION / FILE SECTION - As part of a COBOL FD, RECORDING MODE is used with QSAM files to describe the file/record data: F-Fixed (one record per/block), FB-Fixed/Blocked, V-Variable, U-Undefined (use for Load Modules) and S-Spanned records (extremely long records, that are larger than a block)."
  },
  "RECORDS": {
    "prefix": "RECORDS",
    "body": [
      "FD ${1:CARPOOL}",
      "\tLABEL RECORDS STANDARD",
      "\tRECORD CONTAINS ${2:80} CHARACTERS."
    ],
    "description": "DATA DIVISION / FILE SECTION - As part of a COBOL FD, RECORDS (plural) is used with the LABEL RECORDS clause, which describes the I/O access mode (Sequential/Standard, Varying, etc.) for this file. This is typically used with QSAM files."
  },
  "RECURSIVE": {
    "prefix": "RECURSIVE",
    "body": [
      "PROGRAM-ID. ${1:${TM_FILENAME/(.*)\\..+$/${1:/UPCASE}/}} RECURSIVE."
    ],
    "description": "IDENTIFICATION DIVISION - An optional language element that allows programs to be reentered recursively."
  },
  "REDEFINES": {
    "prefix": "REDEFINES",
    "body": [
      "01 ${1:LAB-REC}.",
      "\t05 ${2:M-UNITS} PIC 9(6).",
      "\t05 ${3:SERUM} PIC 9(6).",
      "\t05 ${4:SERUM-PRICE} REDEFINES FIELD-A PIC 9999V99.",
      "\t05 ${5:SERUM-CLASS} PIC X(3)."
    ],
    "description": "WORKING-STORAGE SECTION - REDEFINES allows one variable to share the same storage as another. It is a way to declare multiple fields for a single storage area in files and WORKING-STORAGE."
  },
  "USING BY REFERENCE": {
    "prefix": "REFERENCE",
    "body": ["PROCEDURE DIVISION USING BY REFERENCE ${1:COMMAREA}"],
    "description": "BY REFERENCE receives an argument/address that was passed by reference (the default). You must define \"COMMAREA\" in the LINKAGE SECTION."
  },
  "RELATIVE": {
    "prefix": "RELATIVE",
    "body": [
      "SELECT ${1:rptfil} ASSIGN TO ${2:rptfilDD}",
      "\tORGANIZATION IS RELATIVE.",
      "\tACCESS MODE IS ${3|SEQUENTIAL,RANDOM,DYNAMIC|}",
      "\tRELATIVE KEY IS ${4:key1}",
      "\tFILE STATUS IS ${5:WS-FILE-STATUS-VAR}.",
      "$0"
    ],
    "description": "Identify VSAM RRDS files in your program by using ORGANIZATION IS RELATIVE. RELATIVE KEY IS associates a logical record with its relative record number."
  },
  "RELEASE": {
    "prefix": "RELEASE",
    "body": [
      "MOVE ${1:SORT-EXT-RECORD} TO ${2:SORT-RECORD}",
      "PERFORM ${3:RELEASE-SORT-RECORD}",
      "RELEASE ${2:SORT-RECORD}"
    ],
    "description": "RELEASE transfers records from an input/output area to the initial phase of a SORT. NOTE: RELEASE can only be used in an INPUT PROCEDURE SECTION."
  },
  "RELEASE FROM": {
    "prefix": "RELEASE FROM",
    "body": [
      "MOVE ${1:SORT-EXT-RECORD} TO ${2:SORT-RECORD}",
      "PERFORM ${3:RELEASE-SORT-RECORD}",
      "RELEASE ${2:SORT-RECORD} FROM ${4:SORT-FILE-IN}"
    ],
    "description": "RELEASE FROM moves data from one group field to the SORT field, then transfers records from an input/output area to the initial phase of a SORT. RELEASE FROM can only be used in an INPUT PROCEDURE SECTION."
  },
  "SERVICE RELOAD": {
    "prefix": "RELOAD",
    "body": ["SERVICE RELOAD ${1:data-name}."],
    "description": "SERVICE RELOAD, a compiler directive. It is syntax checked, but has no effect on the execution of the program."
  },
  "REMAINDER": {
    "prefix": "REMAINDER",
    "body": ["DIVIDE ${1:A} INTO ${2:B} GIVING ${3:C} REMAINDER ${4:D}."],
    "description": "DIVIDE with REMAINDER allows you to specify a numeric data item that you can process as a remainder from the math. REMAINDER is available from all formats of the COBOL DIVIDE statement."
  },
  "REMOVAL": {
    "prefix": "REMOVAL",
    "body": ["CLOSE ${1:fileName} FOR REMOVAL."],
    "description": "FOR REMOVAL applies only to QSAM tape files."
  },
  "RENAMES": {
    "prefix": "RENAMES",
    "body": ["66 ${1:DATA-ITEM5} RENAMES ${2:DATA-ITEM1}."],
    "description": "RENAMES allows you to rename a data-item. The only level-number allowed for RENAMES is 66."
  },
  "RENAMES THRU": {
    "prefix": "RENAMES THRU",
    "body": ["66 ${1:DATA-ITEMX} RENAMES ${2:DATA-ITEM5} THRU ${3:DATA-ITEM1}"],
    "description": "RENAMES THRU allows you to rename multiple consecutively defined data items with the same name. The only level-number allowed for RENAMES is 66."
  },
  "REPLACE": {
    "prefix": "REPLACE",
    "body": [
      "REPLACE ==${1::TAG:}== BY ==${2:EMP-PAY}==.",
      "\t01 ${1::TAG:}.",
      "\t\t02 ${1::TAG:}-WEEK PIC S99.",
      "\t\t02 ${1::TAG:}-GROSS-PAY PIC S9(5)V99.",
      "\t\t02 ${1::TAG:}-HOURS PIC S999 OCCURS 1 TO 52 TIMES",
      "DEPENDING ON ${1::TAG:}-WEEK OF ${1::TAG:}."
    ],
    "description": "REPLACE allows you to rename a source text within a program file. This is typically used when the same physical record layout can assume multiple logical business terms within a program. This is a Compilation (not run-time) level statement that is similar to REPLACING except that it replaces text across an entire file, not simply a copybook."
  },
  "REPLACING": {
    "prefix": "REPLACING",
    "body": ["COPY ${1:PAYLIB} REPLACING ==${2::TAG:}== BY ==${3:EMP-PAY}==."],
    "description": "REPLACING allows you to rename source text within a COBOL Copybook. This is typically used when the same physical record layout can assume multiple logical business terms within a program. This is a Compilation (not run-time) level statement."
  },
  "RERUN": {
    "prefix": "RERUN",
    "body": ["RERUN ON ${1:ddName} EVERY ${2:20000} RECORDS OF ${3:filename}."],
    "description": "RERUN specifies what checkpoints (for rerunning a program) are to be taken at specified intervals."
  },
  "RESERVE": {
    "prefix": "RESERVE",
    "body": [
      "SELECT ${1:TESTDATA}",
      "ASSIGN TO ${2:UT-S-TESTDATA}",
      "\tRESERVE ${3:4} AREAS."
    ],
    "description": "RESERVE allows you to specify the number of I/O buffers to be allocated at run time for QSAM and VSAM files."
  },
  "RESET TRACE": {
    "prefix": "RESET TRACE",
    "body": ["RESET TRACE."],
    "description": "Deprecated but could still be syntax checked depending on your compiler release."
  },
  "RETURN": {
    "prefix": "RETURN",
    "body": [
      "RETURN ${1:SORT-FILE-NAME}",
      "\tAT END MOVE \"${2:YES}\" TO ${3:WS-EOF-SRT-OUTPUT-SW}",
      "\tGO TO ${4:RETURN-SRTD-REC-EXIT}."
    ],
    "description": "The RETURN statement in the OUTPUT PROCEDURE of a COBOL SORT program is a request for the next sorted record."
  },
  "RETURN-CODE": {
    "prefix": "RETURN-CODE",
    "body": ["IF ${1:WS-SWITCH-NO-ERRORS} = \"Y\"", "\tMOVE 0 to RETURN-CODE."],
    "description": "RETURN-CODE is a COBOL special register to pass a return code to the calling program or to z/OS when the program ends."
  },
  "RETURNING": {
    "prefix": "RETURNING",
    "body": [
      "INVOKE ${1:OO-CLASS-NAME} USING ${2:SENDING-FLD}",
      "\tRETURNING ${3:RECEIVING-FLD}."
    ],
    "description": "The RETURNING phrase specifies a data item that will contain the value returned from the invoked method."
  },
  "REVERSED": {
    "prefix": "REVERSED",
    "body": ["OPEN ${1:QSAM-FILE} REVERSED."],
    "description": "REVERSED positions a QSAM file at its end. Successive READ statements make the file records available in reversed order, starting with the last record."
  },
  "WITH NO REWIND": {
    "prefix": "REWIND",
    "body": ["CLOSE ${1:QSAM-FILE} WITH NO REWIND"],
    "description": "REWIND is typically used after WITH NO. An option that positions a QSAM file at its end."
  },
  "REWRITE": {
    "prefix": "REWRITE",
    "body": ["REWRITE ${1:recordName}."],
    "description": "REWRITE Can be used with any DASD (non-Tape) file. It replaces the contents of the current record with the program's FILE SECTION values for that record."
  },
  "REWRITE FROM": {
    "prefix": "REWRITE FROM",
    "body": ["REWRITE ${1:recordName} FROM ${2:WS-RECORD}."],
    "description": "REWRITE FROM can be used with any DASD (non-Tape) file. It moves data from (in the above example) WS-RECORD to the program's FILE SECTION declaration and replaces the record."
  },
  "RIGHT": {
    "prefix": "RIGHT",
    "body": [
      "01 ${1:GROUP-FLD}.",
      "\t05 ${2:ACCTG-CODE} ${3:PIC X(999)} JUSTIFIED RIGHT."
    ],
    "description": "JUSTIFIED overrides COBOL's standard byte-movement rules for receiving data of type: PIC A, PIC X, DBCS, NATIONAL."
  },
  "ROUNDED": {
    "prefix": "ROUNDED",
    "body": [
      "01 ${1:TEMP-RESULT} PIC 9(5)V99 VALUE ZERO.",
      "COMPUTE ${1:TEMP-RESULT} ROUNDED = ${2:mathExpression}."
    ],
    "description": "After decimal point alignment, the number of places in the fraction result of an math statement is compared with the number of places provided for the fraction in the PIC clause. When the size of the fractional result is greater than fraction provided in the PIC clause, truncation occurs unless ROUNDED is specified. The right-most digit of the resultant is increased by 1 whenever the most significant digit of the excess is >= 5."
  },
  "SAME": {
    "prefix": "SAME",
    "body": ["SAME ${1|AREA,SORT,SORT-MERGE|} FOR ${2:filename}."],
    "description": "ENVIRONMENT DIVISION / INPUT-OUTPUT SECTION / I-O-CONTROL - The SAME clause is syntax checked but not executable."
  },
  "SAME RECORD AREA": {
    "prefix": "SAME RECORD AREA",
    "body": ["SAME RECORD AREA FOR ${1:filename}."],
    "description": "ENVIRONMENT DIVISION / INPUT-OUTPUT SECTION / I-O-CONTROL - The SAME RECORD AREA clause specifies that the same main storage be used for two or more files."
  },
  "SD": {
    "prefix": "SD",
    "body": [
      "SD ${1:SORT-FILE}",
      "\tLABEL RECORDS ARE STANDARD",
      "\tBLOCK CONTAINS ${2:number}",
      "\tDATA RECORD IS ${3:SORT-RECORD}.",
      "01 ${4:SORT-RECORD} ${5:PIC X(1324)}."
    ],
    "description": "DATA DIVISION - The SD (SORT DESCRIPTION) defines files that are to be sorted and that are referred to in your PROCEDURE DIVISION's SORT statement."
  },
  "SEARCH": {
    "prefix": "SEARCH",
    "body": [
      "SET SUB TO 1.",
      "\tSEARCH ${1:WS-TABLE}",
      "\tAT END DISPLAY \"${2:ELEMENT NOT FOUND IN TABLE}\"",
      "\tWHEN ${1:WS-TABLE}(SUB) = ${3:WS-SRCH-ELEMENT}",
      "\tDISPLAY \"FOUND IN TABLE\"",
      "END-SEARCH."
    ],
    "description": "SEARCH searches a table sequentially (top to bottom) for an element that satisfies a condition. The SEARCH statement automatically increments the table subscript."
  },
  "SEARCH ALL": {
    "prefix": "SEARCH ALL",
    "body": [
      "SEARCH ALL ${1:WS-TABLE}",
      "\tAT END DISPLAY \"${2:ELEMENT NOT FOUND IN TABLE}\"",
      "\tWHEN ${1:WS-TABLE}(IDX) = ${3:WS-SRCH-ELEMENT}",
      "\tDISPLAY \"FOUND IN TABLE\"",
      "END-SEARCH."
    ],
    "description": "SEARCH searches a table sequentially (top to bottom) for an element that satisfies a condition. The SEARCH statement automatically increments the table subscript."
  },
  "SEARCH WHEN": {
    "prefix": "SEARCH WHEN",
    "body": ["SEARCH ${1:item} WHEN ${2:condition} ${3:item}"],
    "description": "SEARCH WHEN condition item"
  },
  "SELECT": {
    "prefix": "SELECT",
    "body": [
      "SELECT ${1:PATIENT-TRAN-FILE} ASSIGN TO ${2:PATTRAN}",
      "\tORGANIZATION IS ${3|INDEXED,RELATIVE,SEQUENTIAL|}.",
      "\tACCESS MODE IS ${4|SEQUENTIAL,RANDOM,DYNAMIC|}",
      "\tFILE STATUS IS ${5:PAT-TRAN-STATUS}."
    ],
    "description": "DATA DIVISION / FILE DESCRIPTOR - SELECT MODE defines the internal COBOL FD that is assigned to and associated with an external QSAM, VSAM or Line Sequential file."
  },
  "SEPARATE": {
    "prefix": "SEPARATE",
    "body": [
      "01 ${1:VAR-1} PIC S9999 DISPLAY SIGN ${2|LEADING,TRAILING|} SEPARATE."
    ],
    "description": "If both SIGN LEADING (or TRAILING) and SEPARATE are specified, the internal representation of the sign is a full byte, not a half byte as is normal for COMP-3 field declarations."
  },
  "SEQUENCE": {
    "prefix": "SEQUENCE",
    "body": ["PROGRAM COLLATING SEQUENCE IS ${1|EBCDIC,ASCII|}"],
    "description": "COLLATING SEQUENCE determines the type of sequence used in operations on alphanumeric items. (EBCDIC vs. ASCII)"
  },
  "SEQUENTIAL": {
    "prefix": "SEQUENTIAL",
    "body": [
      "SELECT ${1:COMMUTER-FILE} ASSIGN TO ${2:COMMUTR}",
      "ORGANIZATION IS ${3|SEQUENTIAL,LINE SEQUENTIAL|}",
      "ACCESS MODE IS SEQUENTIAL."
    ],
    "description": "FILE CONTROL - SEQUENTIAL specifies that the records in the file are written and read in the order they are entered."
  },
  "SET": {
    "prefix": "SET",
    "body": ["SET ${1:item} TO ${2:value}."],
    "description": "Use the SET statement to assign a value to a: COBOL Table index, POINTER, PROCEDURE POINTER, FUNCTION POINTER or OBJECT REFERENCE."
  },
  "SHIFT": {
    "prefix": "SHIFT",
    "body": [
      "01 ${1|SHIFT-IN,SHIFT-OUT|} GLOBAL PICTURE X(1) USAGE DISPLAY VALUE X\"0F\"."
    ],
    "description": "SHIFT-IN/SHIFT-OUT is a special register that represents EBCDIC shift-in/shift-out control characters. Note that these control characters are unprintable."
  },
  "SIGN": {
    "prefix": "SIGN",
    "body": ["01 ${1:VAR-1} PIC ${2:S9(4)} SIGN ${3|LEADING,TRAILING|}."],
    "description": "The SIGN clause specifies the position and character of the operational sign for signed numeric variables."
  },
  "SIZE ERROR": {
    "prefix": "SIZE ERROR",
    "body": [
      "DIVIDE ${1:TOT-COST} BY ${2:PURCHASED-NBR}",
      "\tGIVING ${3:ANSWER-TOT-COST}",
      "\t\tON SIZE ERROR",
      "\t\tGO TO ${4:MATH-ERR-PARA}",
      "END-DIVIDE"
    ],
    "description": "When arithmetic overflow occurs in a receiving field, the SIZE ERROR clause invokes statements that follow. "
  },
  "DELIMITED BY SIZE": {
    "prefix": "SIZE",
    "body": [
      "STRING",
      "\t${1:LINE-NUMBER SPACE CUSTOMER-INFORMATION}",
      "\tDELIMITED BY SIZE ${2:...}"
    ],
    "description": "DELIMITED BY SIZE moves each field in its entirety to a receiving fields."
  },
  "SKIP1/SKIP2/SKIP3": {
    "prefix": "SKIP",
    "body": ["SKIP${1|1,2,3|}.", "$0"],
    "description": "SKIP n number of lines in a source listing."
  },
  "SORT x on y": {
    "prefix": "SORT",
    "body": ["SORT ${1:fileName} ON ${2:VAR1}${3|., DESCENDING VAR2.|}"],
    "description": "SORT causes a set of records in an external sequential file to be arranged in a user-specified sequence."
  },
  "SORT TABLE": {
    "prefix": "SORT",
    "body": [
      "SORT ${1:varOrTable} ON ${2|ASCENDING,DESCENDING|} ${3:sort-var-key}."
    ],
    "description": "SORT sorts internal COBOL table rows according to the specified COBOL table key fields. It is especially useful for tables used with SEARCH ALL, which is more efficient than default SEARCH."
  },
  "SORT-CONTROL": {
    "prefix": "SORT-CONTROL",
    "body": [
      "01 SORT-CONTROL GLOBAL PICTURE X(8) USAGE DISPLAY",
      "\tVALUE \"IGZSRTCD\"."
    ],
    "description": "The register SORT-CONTROL contains the JCL ddname of the data set that holds control statements used to improve the performance of a sort or merge operation."
  },
  "SORT-CORESIZE": {
    "prefix": "SORT-CORESIZE",
    "body": [
      "01 SORT-CORE-SIZE GLOBAL PICTURE S9(8) USAGE BINARY",
      "\tVALUE ZERO."
    ],
    "description": "SORT-CORE-SIZE is the name of a COMP (binary) variable to declare the number of storage bytes available to the sort utility."
  },
  "SORT-FILE-SIZE": {
    "prefix": "SORT-FILE-SIZE",
    "body": [
      "01 SORT-FILE-SIZE GLOBAL PICTURE S9(8) USAGE BINARY",
      "\tVALUE ZERO."
    ],
    "description": "SORT-FILE-SIZE is the name of a COMP (binary) variable to declare the number of input records to a SORT."
  },
  "SORT-MESSAGE": {
    "prefix": "SORT-MESSAGE",
    "body": [
      "01 SORT-MESSAGE GLOBAL PICTURE X(8) USAGE DISPLAY",
      "\tVALUE \"SYSOUT\"."
    ],
    "description": "The register SORT-MESSAGE contains the JCL ddname of the data set that holds output messages of a sort operation at run-time, in place of the MSGDDN= sort control statement."
  },
  "SORT-MODE-SIZE": {
    "prefix": "SORT-MODE-SIZE",
    "body": [
      "01 SORT-MODE-SIZE GLOBAL PICTURE S9(8) USAGE BINARY",
      "\tVALUE ZERO."
    ],
    "description": "SORT-MODE-SIZE is the name of a COMP (binary) variable to declare the length of variable-length records that occur most frequently."
  },
  "SORT-RETURN": {
    "prefix": "SORT-RETURN",
    "body": [
      "01 SORT-RETURN GLOBAL PICTURE S9(8) USAGE BINARY",
      "\tVALUE ZERO."
    ],
    "description": "SORT-RETURN is the name of a COMP (binary) variable that will contain a return-code from the sort function."
  },
  "SOURCE-COMPUTER": {
    "prefix": "SOURCE-COMPUTER",
    "body": [
      "SOURCE-COMPUTER. ${1:COMPUTER-NAME}${2|., WITH DEBUGGING MODE.|}"
    ],
    "description": "The SOURCE-COMPUTER paragraph is syntax checked unless it contains a WITH DEBUGGING clause which then sets a compile-time switch for debugging."
  },
  "SPACE": {
    "prefix": "SPACE",
    "body": [
      "01 DEBUG-ITEM.",
      "\t02 DEBUG-FIELD PICTURE IS X(6).",
      "\t02 FILLER PICTURE IS X VALUE SPACE"
    ],
    "description": "The figurative constant SPACE or SPACES identify a character field the (EBCDIC) Hex value of \"40\"."
  },
  "SPECIAL-NAMES": {
    "prefix": "SPECIAL-NAMES",
    "body": [
      "ENVIRONMENT DIVISION.",
      "CONFIGURATION SECTION.",
      "SOURCE-COMPUTER. ${1:COMPUTER-NAME}. OBJECT-COMPUTER. ${1:COMPUTER-NAME}",
      "SPECIAL-NAMES.",
      "\tALPHABET SPECIAL-SEQUENCE IS",
      "\t\t\"A\" Also \"a\"",
      "\t\t\"B\" Also \"b\"",
      "\t\t${2:...}"
    ],
    "description": "The SPECIAL-NAMES paragraph is the name of an ENVIRONMENT DIVISION, CONFIGURTION SECTION paragraph in which user-specified mnemonic-names are releated to environment-names."
  },
  "EXEC SQLIMS": {
    "prefix": "EXEC SQLIMS",
    "body": ["EXEC SQLIMS", "\t${1:SQL statement}", "END-EXEC."],
    "description": "The EXEC SQLIMS statements invoke a Compiler option, which allows you to access IMS Databases through SQL relational statements. There is a wide variety of SQLIMS options and the setup for this functionality must be installed and configured. "
  },
  "STANDARD": {
    "prefix": "STANDARD",
    "body": [
      "FD ${1:INPATIENT-REC}",
      "\tLABEL RECORD STANDARD",
      "\tBLOCK CONTAINS ${2:0} CHARACTERS",
      "\tRECORD CONTAINS ${3:80} CHARACTERS."
    ],
    "description": "DATA DIVISION / FILE SECTION - LABEL RECORDS documents the presence or absence of labels. STANDARD LABELS conform to system specifications."
  },
  "STANDARD-1": {
    "prefix": "STANDARD-1",
    "body": [
      "OBJECT-COMPUTER. ${1:COMPUTER-NAME}.",
      "\tPROGRAM COLLATING SEQUENCE IS ASCII-SEQUENCE.",
      "\tSPECIAL-NAMES. ALPHABET ASCII-SEQUENCE IS STANDARD-1."
    ],
    "description": "STANDARD-1 specifies that the ASCII collating sequence is used for all alphanumeric comparisons."
  },
  "STANDARD-2": {
    "prefix": "STANDARD-2",
    "body": [
      "OBJECT-COMPUTER. ${1:COMPUTER-NAME}.",
      "\tPROGRAM COLLATING SEQUENCE IS ASCII-SEQUENCE.",
      "\tSPECIAL-NAMES. ALPHABET ASCII-SEQUENCE IS STANDARD-2."
    ],
    "description": "STANDARD-2 specifies that the ISO/IEC 646, 7-bit coded character set collating sequence is used for all alphanumeric comparisons."
  },
  "START": {
    "prefix": "START",
    "body": ["START ${1:INPAT-FILE} ${2:KEY IS > `AAAAA`}", "END-START."],
    "description": "START positions record retrieval within an indexed or relative file for subsequent sequential retrieval. Note that START does not READ a record."
  },
  "STATUS": {
    "prefix": "STATUS",
    "body": [
      "SELECT ${1:INPAT} ASSIGN TO ${2:UT-S-INPAT}",
      "FILE STATUS IS ${3:WS-INPAT-STATUS}."
    ],
    "description": "FILE STATUS monitors the execution of each input-output operation for a file, and moves the operation's return code into the specified variable."
  },
  "STOP": {
    "prefix": "STOP",
    "body": ["STOP RUN."],
    "description": "STOP RUN terminates all COBOL routines. Control is returned immediately to z/OS. Note that GOBACK is a safer or better approach to ending a program."
  },
  "SHELL": {
    "prefix": "SHELL",
    "body": [
      "       IDENTIFICATION DIVISION.",
      "       PROGRAM-ID. ${1:${1:${TM_FILENAME/(.*)\\..+$/$1/}}}.",
      "       ENVIRONMENT DIVISION.",
      "       CONFIGURATION SECTION.",
      "       SPECIAL-NAMES.",
      "       INPUT-OUTPUT SECTION.",
      "       FILE-CONTROL.",
      "       DATA DIVISION.",
      "        FILE SECTION.",
      "        WORKING-STORAGE SECTION.",
      "        LINKAGE SECTION.",
      "       PROCEDURE DIVISION.",
      "        MAIN-PROCESSING SECTION.",
      "         MAINLINE-PARAGRAPH.",
      "             $0",
      "             STOP RUN."
    ],
    "description": "TEMPLATE PROGRAM"
  },
  "STRING": {
    "prefix": "STRING",
    "body": [
      "STRING ${1:item1} DELIMITED BY SIZE",
      "\t${2:item2} DELIMITED BY SIZE",
      "\tINTO ${3:RESULT}",
      "END-STRING",
      "$0"
    ],
    "description": "STRING selects and formats information from data source(s) into a receiving field."
  },
  "SUBTRACT": {
    "prefix": "SUBTRACT",
    "body": ["SUBTRACT ${1:A} FROM ${2:B} GIVING ${3:C}"],
    "description": "SUBTRACT subtracts one numeric variable, or the sum of two or more numeric variables, from one or more numeric variables, and stores the result."
  },
  "SUBTRACT CORRESPONDING": {
    "prefix": "SUBTRACT CORRESPONDING",
    "body": ["SUBTRACT CORRESPONDING ${1:A} FROM ${2:B} GIVING ${3:C}"],
    "description": "SUBTRACT CORRESPONDING subtracts variables of the same name between two group variables and stores the result."
  },
  "COMPUTE SUM (Values)": {
    "prefix": "SUM",
    "body": [
      "COMPUTE ${1:resultNum} = FUNCTION SUM(${2:arg-1},${3:arg-2},${4:arg-3})"
    ],
    "description": "The SUM function returns a value that is the sum of the arguments."
  },
  "COMPUTE SUM (Table)": {
    "prefix": "SUM",
    "body": [
      "01 ${1:EMP-TAB-WS}.",
      "\t05 ${2:EMPLOYEE-REC} OCCURS ${3:1000} TIMES",
      "\t\t10 ${4:EMPLOYEE-SAL} PIC S9(7)V99 COMP-3.",
      "COMPUTE ${5:TOT-EMPLOYEE-PAYROLL} = FUNCTION SUM(${4:EMPLYOYEE-SAL}(ALL))"
    ],
    "description": "The SUM function returns a value that is the sum of all rows in an internal COBOL table."
  },
  "SUPPRESS (XML)": {
    "prefix": "SUPPRESS",
    "body": [
      "XML GENERATE ${1:DOC} FROM ${2:GOOD-DOC}",
      "\tSUPPRESS ${2:PATIENT-INFO}",
      "\t\tEVERY NONNUMERIC ELEMENT WHEN SPACE",
      "\t\tEVERY NUMERIC ELEMENT WHEN ZERO",
      "END-XML."
    ],
    "description": "SUPPRES excludes individual data items from an XML GENERATE."
  },
  "SUPPRESS (Copy)": {
    "prefix": "SUPPRESS",
    "body": ["COPY ${1:ABC-COPY-BOOK} SUPPRESS."],
    "description": "SUPPRESS specifies that the library text is not to be printed on the source listing."
  },
  "SYMBOLIC CHARACTERS": {
    "prefix": "SYMBOLIC CHARACTERS",
    "body": ["SYMBOLIC CHARACTERS ${1:BACKSPACE IS 23}"],
    "description": "The SYMBOLIC CHARACTERS clause provides a means of specifying one or more single-byte, symbolic characters assigned to an EBCIDIC/ASCII hex value."
  },
  "SYNCHRONIZED": {
    "prefix": "SYNCHRONIZED",
    "body": ["01 ${1:GROUP-VAR}", "\t05 ${2:IDX-VAR} PIC S9(4) COMP SYNC."],
    "description": "The SYNC/SYNCHRONIZED clause specifies the alignment of an elementary item on a natural boundary in z/OS main storage."
  },
  "TALLY": {
    "prefix": "TALLY",
    "body": ["01 TALLY GLOBAL PICTURE 9(5) COMP VALUE ZERO."],
    "description": "TALLY is a special register named as a binary (COMP) data item. When used in nested programs, this special register is implicitly declared with this global variable in the outermost program. You can refer to or modify the contents of TALLY throughout the nested program."
  },
  "TALLYING (Inspect)": {
    "prefix": "TALLYING",
    "body": [
      "INSPECT ${1:INPAT-ADDRESS}",
      "\tTALLYING ${2:INPAT-COUNTR} FOR LEADING \" \"",
      "\tREPLACING FIRST \" \" BY \"|\"."
    ],
    "description": "TALLYING counts the occurrences of a specific character or special character in the INSPECT, STRING or UNSTRING data item."
  },
  "TALLYING (UNSTRING)": {
    "prefix": "TALLYING",
    "body": [
      "UNSTRING ${1:INPAT-FLDS}",
      "\tDELIMITED BY SPACES ",
      "\tINTO ${2:WS-INPAT}",
      "\tTALLYING IN ${3:INPAT-FLDS-FILLED}",
      "END-UNSTRING."
    ],
    "description": "TALLYING counts the occurrences of a specific character or special character in the INSPECT, STRING or UNSTRING data item."
  },
  "If x THEN": {
    "prefix": "THEN",
    "body": [
      "IF ${1:statement-1} THEN",
      "\t${2:ifTrue}",
      "ELSE",
      "\t${3:ifNotTrue}",
      "END-IF."
    ],
    "description": "Use THEN in an IF ... ELSE statement to code a formal (English-language) choice between processing actions. Note that the word THEN is optional."
  },
  "PERFORM x THRU y": {
    "prefix": "PERFORM THRU",
    "body": ["PERFORM ${1:PROCESS-PATIENT} THRU ${2:PROCESS-PATIENT-EXIT}"],
    "description": "THROUGH (or THRU) in a PERFORM statement tells the runtime to execute all paragraphs and statements from the named-paragraph THRU the EXIT paragraph."
  },
  "VALUE x THRU y": {
    "prefix": "VALUE THRU",
    "body": [
      "01 WS-YEAR-VALUES.",
      "\t05 WS-INIT-YEAR PIC 9(4).",
      "\t\t88 VALID-YEAR   VALUE 1960 THRU 2022.",
      "\t\t88 INVALID-YEAR VALUE 0001 THRU 1959",
      "\t\t                      2023 THRU 9999."
    ],
    "description": "THROUGH (or THRU) in an 88-declaration tells the compiler that all sequential values after VALUE to the THRU value are assigned to the 88."
  },
  "TIME": {
    "prefix": "TIME",
    "body": [
      "ACCEPT ${1:WS-TIME-ITEM} FROM TIME.",
      "DISPLAY \"CURRENT TIME IS: \"${1:WS-TIME-ITEM}."
    ],
    "description": "The reserved word TIME is a special register that returns the current time in your system-format."
  },
  "OCCURS x TIMES": {
    "prefix": "TIMES",
    "body": [
      "01 ${1:WS-PATIENT-TBL}.",
      "\t05 ${2:WS-PATIENT-DATA} OCCURS ${3:99} TIMES."
    ],
    "description": "TIMES when used in a table declaration defines the number of instances a variable occurs within a table."
  },
  "PERFORM x THRU y num TIMES": {
    "prefix": "TIMES",
    "body": [
      "PERFORM ${1:PROCESS-PAT-EDIT} THRU ${2:PAT-EDIT-EXT} ${3:99} TIMES."
    ],
    "description": "TIMES when used in a COBOL loop construct declares the number of iterations the logic is looped through."
  },
  "SELECT x ASSIGN TO y": {
    "prefix": "TO",
    "body": [
      "\tSELECT ${1:FILE-1} ASSIGN TO ${2:EXTFILE1}",
      "ORGANIZATION IS INDEXED"
    ],
    "description": "FILE CONTROL - TO as part of a SELECT/ASSIGN statement associates the internal COBOL filename (after SELECT) to an external data set name."
  },
  "IF x GREATER/LESS THAN OR EQUAL TO y": {
    "prefix": "TO",
    "body": [
      "IF ${1:statement-1} ${2|GREATER,LESS|} THAN OR EQUAL TO ${3:statement-2} THEN",
      "\t${4:ifTrue}",
      "ELSE",
      "\t${5:ifNotTrue}",
      "END-IF."
    ],
    "description": "TO as part of an IF statement directs the runtime to evaluate the value after the word IF to the value after TO and take appropriate action."
  },
  "TO": {
    "prefix": "TO",
    "body": ["TO ${1:item}"],
    "description": "TO item"
  },
  "TO ITEM1 ITEM2": {
    "prefix": "TO ITEM1 ITEM2",
    "body": ["TO ${1:item} ${2:item}"],
    "description": "TO item1 item2"
  },
  "TRAILING": {
    "prefix": "TRAILING",
    "body": ["01 ${1:VAR-1} PIC ${2:S9(4)} SIGN TRAILING."],
    "description": "SIGN TRAILING declares the position of the operational sign (plus or minus) for a numeric variable."
  },
  "EVALUATE TRUE": {
    "prefix": "EVALUATE TRUE",
    "body": [
      "EVALUATE TRUE",
      "\tWHEN ${1:VAR-A} = ${2:VAR-B}",
      "\t\tMOVE \"${1:VAR-A} - ${2:VAR-B} EQUAL\" TO DISP-OUT.",
      "\tWHEN ${3:VAR-C} = ${4:VAR-D}",
      "\t\tMOVE \"${3:VAR-C} - ${4:VAR-D} EQUAL\" TO DISP-OUT.",
      "END-EVALUATE."
    ],
    "description": "Use EVALUATE TRUE instead of a series of nested IF statements to test multiple conditions and specify distinct actions for each."
  },
  "SET x TRUE": {
    "prefix": "SET TRUE",
    "body": ["IF NO-MORE-RECORDS", "\tSET EOF-CONDITION TRUE"],
    "description": "When a SET statement is executed, the value associated with a condition-name is placed in its 88-Level according to the rules of the VALUE clause."
  },
  "JSON GENERATE TYPE": {
    "prefix": "TYPE",
    "body": [
      "JSON GENERATE ${1:JASON-STMT} FROM ${2:IN-FILE-TEXT} COUNT IN ${3:JSON-CHAR-CTR}",
      "\tTYPE OF ${4:VAR-MSG} IS ${5:attribute}",
      "\tON EXCEPTION DISPLAY \"JSON GENERATE ERROR: \" ${6:WS-JS-CODE}",
      "END-JSON"
    ],
    "description": "The TYPE phrase allows you to control attribute and element generation."
  },
  "UNSTRING": {
    "prefix": "UNSTRING",
    "body": [
      "UNSTRING ${1:PAT-DETAILS-IN-REC}",
      "\t${2:LNAME, FNAME, MID-INIT, DETAILS} DELIMITED BY SIZE",
      "END-UNSTRING."
    ],
    "description": "UNSTRING selects and formats information from data source(s) into a receiving field."
  },
  "PERFORM UNTIL": {
    "prefix": "UNTIL",
    "body": [
      "PERFORM ${1:PAT-IN-REC-EDITS} THRU ${2:PAT-IN-REC-EDITS-EXIT}",
      "\tUNTIL ${3:NO-MORE-PAT-IN-RECS}",
      "END-PERFORM."
    ],
    "description": "UNTIL tells the runtime to execute procedures referred to until a specified condition tests true, or if an UNTIL EXIT is reached."
  },
  "UP BY": {
    "prefix": "UP BY",
    "body": ["SET ${1:indexName} UP BY ${2:numVarLiteral}"],
    "description": "SET x UP is equivalent to a ADD statement, except referring to a COBOL table index or a COBOL pointer variable."
  },
  "UPON": {
    "prefix": "UPON",
    "body": ["UPON ${1:mnemName|envName}"],
    "description": "UPON mnemName|envName"
  },
  "UPON CONSOLE": {
    "prefix": "UPON CONSOLE",
    "body": ["DISPLAY \"SERIOUS DB2 ERROR\"", "\tUPON CONSOLE."],
    "description": "UPON CONSOLE (or environment-name) or the environment name associated with an output device copies what is to be displayed to an output device defined in the ENVIRONMENT DIVISION."
  },
  "USAGE": {
    "prefix": "USAGE",
    "body": ["01 ${1:VAR1} ${2:PIC X(8)} USAGE IS DISPLAY"],
    "description": "USAGE provides details about the intention of a given variable."
  },
  "CALL x USING y": {
    "prefix": "USING",
    "body": ["CALL \"${1:PATEDITS}\" USING ${2:WS-PAT-DETAILS, WS-PAT-RETC}."],
    "description": "The WORKING-STORAGE SECTION parameters referenced by the USING phrase are made available to the called subprogram at the time the CALL is executed."
  },
  "JSON PARSE USING": {
    "prefix": "USING",
    "body": [
      "JSON PARSE ${1:id} INTO ${2:id}",
      "\tCONVERTING ${3:id} FROM BOOLEAN USING ${4:data-flag-b}"
    ],
    "description": "USING provides various methods of specifying the values that are moved after the JSON PARSE conversion."
  },
  "USING VALUE": {
    "prefix": "USING",
    "body": ["USING VALUE ${1:id}"],
    "description": "USING VALUE"
  },
  "UTF-8": {
    "prefix": "UTF-8",
    "body": ["01 ${1:UTF-8-VAR} PIC X(8) USAGE UTF-8."],
    "description": "Literals identified by the opening delimiter U\" or U' are UTF-8 literals. They can contain any single-byte or double-byte characters."
  },
  "VALIDATING": {
    "prefix": "VALIDATING",
    "body": ["VALIDATING ${1:item}"],
    "description": "VALIDATING item"
  },
  "VALUE": {
    "prefix": "VALUE",
    "body": [
      "01 ${1:WS-VAR} PIC X(20) VALUE \"${2:textHere}\".",
      "\t88 ${3:WS-SUBVAR} VALUE \"${4:textHere}\". "
    ],
    "description": "WORKING-STORAGE SECTION - VALUE/VALUES specifies the initial contents of a variable or the value(s) associated with an 88-level condition name."
  },
  "VALUE OF": {
    "prefix": "VALUE OF",
    "body": [
      "FD ${1:QSAM-FILE}",
      "\t\tLABEL RECORDS ARE STANDARD",
      "\t\tRECORDING MODE IS FBA",
      "\t\tBLOCK CONTAINS 0",
      "\t\tVALUE OF ${2:system-name} IS ${3:working-storage-field}",
      "\t\tDATA RECORD IS ${4:RPT-OUT-REC}."
    ],
    "description": "The VALUE OF clause describes a WORKING-STORAGE item in the label records associated with the file."
  },
  "VARYING": {
    "prefix": "VARYING",
    "body": [
      "PERFORM ${1:TBL-EDIT-RTN} THRU ${2:TBL-EDIT-EXIT}",
      "\tVARYING ${3:TBL-IDX} FROM 1 BY 1 ",
      "\tUNTIL ${3:TBL-IDX} >= ${4:WS-TBL-MAX}."
    ],
    "description": "PROCEDURE DIVISION - VARYING increases or decreases the value of one or more variable subscripts or table indexes. Note that the PERFORM statement can be an inline PERFORM that varies a variable from low-to-high."
  },
  "RECORD IS VARYING": {
    "prefix": "VARYING",
    "body": [
      "FD ${1:MSTR-FILE}",
      "\tRECORDING MODE IS VB",
      "\tRECORD IS VARYING FROM ${1:10} TO ${2:200} CHARACTERS."
    ],
    "description": "VARYING in a COBOL FD or SD describes the lowest and highest number of bytes contained in the variable length file."
  },
  "VOLATILE": {
    "prefix": "VOLATILE",
    "body": [
      "01 ${1:ONLINE-DATA-COLLECTION-VARS}.",
      "\t03 ${2:SCREEN-ITEMS-A-SECTION} VOLATILE.",
      "\t\t05 ${3:SCREEN-A1} PIC S9(3)V99 COMP SYNC.",
      "\t\t05 ${4:SCREEN-A2} PIC S9(5)V99 COMP SYNC.",
      "\t03 ${5:SCREEN-ITEMS-B-SECTION}.",
      "\t\t05 ${6:SCREEN-B1} PIC S9(9).",
      "\t\t05 ${7:SCREEN-B2} PIC S9(9) VOLATILE."
    ],
    "description": "VOLATILE indicates that a variable's value can be modified or referenced in ways that the COBOL compiler cannot detect, e.g. a Language Environment (LE) condition handler."
  },
  "WHEN (EVALUATE)": {
    "prefix": "WHEN",
    "body": [
      "EVALUATE ${1:VAR-TO-EVALUATE}",
      "\tWHEN ${2:statement-1}",
      "\t\t${3:doThisWhenTrue}",
      "\tWHEN ${4:statement-2}",
      "\t\t${5:doThisWhenTrue}",
      "END-EVALUATE."
    ],
    "description": "The WHEN clause, when used with EVALUATE is a succinct way of specifying IF conditionals."
  },
  "WHEN (Search)": {
    "prefix": "WHEN",
    "body": [
      "SEARCH ${1:tableToSearch}",
      "\tAT END",
      "\t\tMOVE ${2:-1} TO RETURN-CODE",
      "\tWHEN ${3:conditionalStatement}",
      "\t\t${4:doThisWhen}",
      "END-SEARCH."
    ],
    "description": "In a COBOL SEARCH operation WHEN is used as the conditional test keyword."
  },
  "WHEN OTHER": {
    "prefix": "WHEN OTHER",
    "body": ["WHEN OTHER", "\t${1:impStat}"],
    "description": "WHEN OTHER"
  },
  "WHEN-COMPILED #1": {
    "prefix": "WHEN-COMPILED",
    "body": ["MOVE FUNCTION WHEN-COMPILED WS-PIC-X-21-BYTE-FLD."],
    "description": "Use the COBOL instrinsic function WHEN-COMPILED to determine when a program was compiled. The resultant alphanumeric format is: YYYYMMDDHHMMSSHH from Greenwich Mean Time."
  },
  "WHEN-COMPILED #2": {
    "prefix": "WHEN-COMPILED",
    "body": ["01 WHEN-COMPILED GLOBAL PICTURE X(16)."],
    "description": "Use the COBOL instrinsic function WHEN-COMPILED to determine when a program was compiled. The resultant alphanumeric format is: YYYYMMDDHHMMSSHH from Greenwich Mean Time."
  },
  "CLOSE WITH": {
    "prefix": "WITH",
    "body": ["CLOSE ${1:filename} WITH LOCK."],
    "description": "CLOSE x WITH LOCK specifies that the file cannot be opened again while the program is running."
  },
  "DISPLAY x WITH NO ADVANCING": {
    "prefix": "WITH NO ADVANCING",
    "body": ["DISPLAY \"${1:CICS ABEND ERROR}\" WITH NO ADVANCING."],
    "description": "DISPLAY x WITH NO ADVANCING places a + sign in byte one of the output sent to a DDNAME."
  },
  "PERFORM WITH": {
    "prefix": "WITH",
    "body": [
      "PERFORM ${1:INPAT-EDITS} WITH TEST AFTER VARYING ${2:WS-INPAT-IDX}",
      "FROM 1 BY 1 UNTIL ${2:WS-INPAT-IDX} >= ${3:99}",
      "END-PERFORM."
    ],
    "description": "As part of a PERFORM (loop) construct, WITH TEST AFTER (or WITH TEST BEFORE) allows you to control whether or not at least a single loop occurs."
  },
  "WRITE x FROM y": {
    "prefix": "WRITE",
    "body": [
      "WRITE ${1:x} FROM ${2:y}",
      "END-WRITE.",
      "IF ${3:WS-OUTPUT-STATUS-CODE} NOT EQUAL 0",
      "\t${4:I/O-Error-Logic}",
      "END-IF."
    ],
    "description": "The format of the WRITE phrase in the PROCEDURE DIVISION is dependent on the file-type being processed. i.e. VSAM, QSAM, etc. It also has several optional subordinate clauses for specific I/O error trapping."
  },
  "WRITE x FROM y BEFORE ADVANDING z lines": {
    "prefix": "WRITE",
    "body": [
      "WRITE ${1:x} FROM ${2:y}",
      "\tBEFORE ADVANCING ${3:2} LINES",
      "END-WRITE.",
      "IF ${4:WS-OUTPUT-STATUS-CODE} NOT EQUAL 0",
      "\t${5:I/O-Error-Logic}",
      "END-IF."
    ],
    "description": "The format of the WRITE phrase in the PROCEDURE DIVISION is dependent on the file-type being processed. i.e. VSAM, QSAM, etc. It also has several optional subordinate clauses for specific I/O error trapping."
  },
  "WRITE x FROM y INVALID KEY PERFORM z": {
    "prefix": "WRITE",
    "body": [
      "WRITE ${1:x} FROM ${2:y}",
      "\tINVALID KEY PERFORM ${3:z}",
      "END-WRITE."
    ],
    "description": "The format of the WRITE phrase in the PROCEDURE DIVISION is dependent on the file-type being processed. i.e. VSAM, QSAM, etc. It also has several optional subordinate clauses for specific I/O error trapping."
  },
  "WRITE item": {
    "prefix": "WRITE item",
    "body": ["WRITE ${1:item}"],
    "description": "WRITE item"
  },
  "APPLY WRITE ONLY": {
    "prefix": "WRITE-ONLY",
    "body": ["AWO."],
    "description": "ENVIRONMENT DIVISION / FILE-CONTROL / I-O-CONTROL - Use the compiler option AWO (APPLY WRITE-ONLY) to make optimal use of buffering on the I/O device. Note that Enterprise COBOL v6 describes I/O efficiency savings as being upwards of 90%."
  },
  "XML PARSE": {
    "prefix": "XML PARSE",
    "body": [
      "XML PARSE ${1:LS-XML-INPAT-DOC} ",
      "\tPROCESSING PROCEDURE COUNTELEMENTS",
      "\tMOVE LENGTH OF ${2:XML-DOCUMENT} TO ${3:WS-DOC-SIZE}."
    ],
    "description": "PROCEDURE DIVISION - The XML reserved word which invokes IBM's XML parser is followed by a number of options for parsing or generating XML documents. Note that the detailed IBM documentation contains complete generating information."
  },
  "XML-CODE": {
    "prefix": "XML-CODE",
    "body": ["01 ${1:XML-CODE} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "The special register XML-CODE communicates the status between the IBM XML parser and the XML  procedure invoked in an XML PARSE statement. It indicates either that an XML GENERATE was successful or not."
  },
  "XML-EVENT": {
    "prefix": "XML-EVENT",
    "body": ["01 ${1:XML-EVENT} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "XML-EVENT is a special register that passes run-time event information from the XML parser to the processing procedure identified in the XML PARSE statement."
  },
  "XML-INFORMATION": {
    "prefix": "XML-INFORMATION",
    "body": ["01 ${1:XML-INFORMATION} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "The XML-INFORMATION special register is used to provide additional information to an XML PARSE processing procedure about the status of the executing code."
  },
  "XML-NAMESPACE": {
    "prefix": "XML-NAMESPACE",
    "body": ["01 ${1:XML-NAMESPACE} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "XML-NAMESPACE special register passes event information from the XML parser to the processing procedure identified in the XML PARSE statement."
  },
  "XML-NAMESPACE-PREFIX": {
    "prefix": "XML-NAMESPACE-PREFIX",
    "body": ["01 ${1:XML-NAMESPACE-PREFIX} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "XML-NAMESPACE-PREFIX contains the identifier of the namespace, if any, associated with the name in XML-TEXT for XML events."
  },
  "XML-NTEXT": {
    "prefix": "XML-NTEXT",
    "body": ["01 ${1:XML-NTEXT} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "XML-NTEXT contains document fragments that are represented in usage NATIONAL."
  },
  "XML-SCHEMA": {
    "prefix": "XML-SCHEMA",
    "body": ["01 ${1:XML-SCHEMA} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "XML-SCHEMA relates <xml-schema-name-1> to an external file identifier such as a ddname or environment variable which identifies the actual external file that contains the optimized XML schema."
  },
  "XML-TEXT": {
    "prefix": "XML-TEXT",
    "body": ["01 ${1:XML-TEXT} PIC S9(9) USAGE BINARY VALUE 0."],
    "description": "XML-TEXT contains document fragments that are represented in usage DISPLAY (PIC A, or PIC X)."
  },
  "MOVE ZERO": {
    "prefix": "ZERO",
    "body": ["MOVE ZERO TO ${1:WS-NUM-ITEM1}."],
    "description": "ZERO and its synonyms represent the numeric value zero (0) or one or more occurrences of the character zero (in EBCDIC: xF0)."
  },
  "VALUE ZERO": {
    "prefix": "ZERO",
    "body": ["01 ${1:VAR-BIN} PIC S9(4)V99 COMP-3 VALUE ZERO."],
    "description": "VALUE ZERO when used in a variable declaration initiaizes the field to the numeric value zero (0)."
  }
}