*COMDECK,SETBOUNDS
        PROC SETBOUNDS; 
#  THIS PROC SETS HIGH AND/OR LOW BOUNDS OF KEY VALUES USED TO ACCESS # 
# THE FILE. THIS IS DONE BY EXAMINING THE BIT PAIRS WHICH MAKE UP THE#
#  RANGE TABLE.  EACH BITPAIR CONSISTS OF A LESS-THAN BIT (LOW-ORDER) # 
#  AND AN EQUAL-TO BIT (HIGH-ORDER).  THUS, 00 IS GREATER THAN,       # 
#  01 IS EQUAL TO, 10 IS LESS THAN, AND 11 IS LESS THAN OR EQUAL TO.  # 
#  THE BOUNDARIES WHICH ARE SET ARE USED TO POSITION THE FILE IN ORDER# 
#  TO READ THE FIRST RECORD WITH A KEY VALUE WHICH MEETS THE CRITERIA # 
#  A MAXIMUM OF 28 BIT PAIRS IS ALLOWED.                              # 
          BEGIN 
          BITPAIR = 0;
          FOR DUMMY2=0 WHILE BITINDEX LQ 56 AND BITPAIR EQ 0 DO 
            BEGIN 
            BITINDEX = BITINDEX + 2;
            BITPAIR = B<BITINDEX,2>BITPATTERN;
            END 
          IF BITINDEX GR 56 
            THEN
            BEGIN 
            RC = EOICODE; 
            RETURN; 
            END 
          IF BITPAIR GQ 2 THEN
            LOWKEYSORD = BITINDEX/2 - 1;  # LT OR LE# 
            ELSE LOWKEYSORD = BITINDEX/2;   # GT OR EQ #
          IF BITPAIR NQ 2 
            THEN
            BEGIN 
            BITPAIR = 3;
#  FOR ANYTHING BUT A LESS THAN, LOOK FOR A HIGH BOUNDARY.  # 
            FOR DUMMY2=0 WHILE BITINDEX LQ 56 AND BITPAIR EQ 3 DO 
              BEGIN 
              BITINDEX = BITINDEX + 2;
              BITPAIR = B<BITINDEX,2>BITPATTERN;
              END 
            END 
          IF BITPAIR LS 2 
            THEN
            BEGIN 
            BITINDEX = BITINDEX -2; 
            USEHIBOUND = TRUE;
            END 
            ELSE USEHIBOUND = FALSE;
          HIGHKEYSORD = BITINDEX/2; 
          WORDLOC = HIGHKEYSORD/5;
          BITLOC = 12 * (HIGHKEYSORD - 5*WORDLOC);
#  GET THE ADDRESS OF THE HIGH KEY BOUNDARY FROM THE RANGE TABLE #
          P<HIGHKEYVALUE> = B<BITLOC,12>RTBLWORD[WORDLOC+1] + RTBLLOC;
          IF LOWKEYSORD GQ 0
            THEN
            BEGIN 
            WORDLOC = LOWKEYSORD/5; 
            BITLOC = 12 * (LOWKEYSORD - 5*WORDLOC); 
#  GET THE LOW KEY BOUNDARY, IF THERE IS ONE.  IF IT DOES NOT EXIST, #
#  START READING FROM BEGINNING OF INFORMATION.  #
            P<LOWKEYVALUE> = B<BITLOC,12>RTBLWORD[WORDLOC+1] + RTBLLOC; 
            END 
            ELSE POSITIONED = TRUE; 
  
          P<FIT> = P<AREAFIT>;                                           NEXTGET
          IF FITFO EQ FOSQ THEN    #SEQUENTIAL FILE.                   # NEXTGET
            BEGIN 
            POSITIONED = TRUE;
            CHKLOWBOUND = TRUE; 
            END 
            ELSE CHKLOWBOUND = FALSE; 
          RETURN; 
          END 
