$listoff
stdenv;
(*--------------------------------------------
--
--             System Standard Environment for RTP
--
--   87.09.27   TOG   First version.
--   92.06.04   HEJ   Type bufparamtype added.
--   92.06.12   HEJ   A number of open routines added ( eg. for IMC ).
--                    - Type compilerid_type, procedure ownversion.
--   92.06.12   HEJ   Extra open routines removed.
--   92.06.19   HEJ   The type of index changed:  byte -> integer,
--                    - parameter of locktest changed: mailbox -> reference
--   92.06.29   HEJ   Like Telebit: add nl and alfalength to stdenv.
--
-----------------------------------------------
*)

(***** predefined constants *****)
const
alfalength = 12;
maxint = 32767;
minint = -32768;
nl     = lf;


(***** predefined types *****)
type

bit = 0..1;

byte = 0..255;


conn_service = (cs_normal, cs_high);

const create_ok=0;
      create_process_not_nil=1;
      create_program_not_linked=2;
      create_no_memory=3;

type create_result = create_ok .. create_no_memory;

const
maxpriority = 0;
minpriority = -2;
stdpriority = minpriority;

type
priotype = minpriority..maxpriority;


event_type = (not_event, message_event, answer_event,
              process_removed, port_closed, disconnected,
              letter_sent, letter_arrived,
              local_connect, remote_connect,
              reset_indication, reset_completion,
              credit, data_sent, data_arrived, data_overrun,
              dummy_letter, dummy_lcnct, dummy_rcnct,
              dummy_rindic, dummy_rcmpl, dummy_credit,
              dummy_sent, dummy_arrived,
              msl_message, msl_answer, test_event);

const link_ok=0;
      link_not_found=1;
      link_no_parameter_match=3;
      link_already_linked=6;

type link_result=link_ok..link_already_linked;

const unlink_ok=0;
      unlink_no_program_linked=1;
      unlink_program_busy=2;

type unlink_result=unlink_ok..unlink_program_busy;

const mem_private = 0;

type mem_type = mem_private..mem_private;

reason_type = (reason_ok, reason_name, reason_resource,
               reason_closed, reason_network);

scope_type = (anonymous, local, regional, global);

string(length: byte) = array(1..length) of char;

alfa = string(12);

activation = (a_interrupt, a_mailbox, a_delay);

control_type = packed record
                 rcv_all,
                 get_credit: boolean;
               end;


(* shielded type declarations *)
(******************************)

mailbox_ = record
             nulbyte: byte;
             mbx    : ^integer; -- ^proc or ^header
             chain  : ^integer; -- ^mbx
           end;

pool_ = record
          nulbyte: byte;
          mbx    : ^integer; -- ^proc or ^header
          chain  : ^integer; -- ^pool_
        end;

process_ = record
            data : ^integer; -- ^proc
            chain: ^integer; -- ^process
          end;


reference_ = record
               locked : byte;
               message: ^integer; -- ^header
               chain  : ^integer; -- ^ref
             end;


chain_ = record
           message:  ^integer; -- ^header
           start  :  ^integer; -- ^header
           length :   integer;
         end;

port_ = record
           index_limit : byte;
           imc_box     : ^mailbox;
           port_active : mailbox;
           port_ready  : mailbox;
           port_answer : mailbox;
        end;

program_descriptor = record
          count     : integer;
          paramtypes: ^integer;
          state     : integer;
          lbdr      : ^integer; -- ^lbdr
          name      : array(1..12) of char;
          chain     : ^integer; -- ^prog
        end;

(*****  PREDEFINED ROUTINES  *****)
(*********************************)


FUNCTION abs(n: integer): integer;
BEGIN
abs 2 35 2 34 2
END;

PROCEDURE alloc( VAR r: reference; VAR p: pool; VAR ra: mailbox);
EXTERNAL;

FUNCTION allocdelay(VAR r: reference; VAR p:pool; VAR ra: mailbox;
                     ms: integer): activation;
EXTERNAL;

FUNCTION allocmempool(VAR p: pool; no_of_bufs, bufsize: integer;
mem: mem_type): integer;
EXTERNAL;

FUNCTION allocpool=allocpool_rc
         (VAR p: pool; no_of_bufs, bufsize: integer): integer;
EXTERNAL;

PROCEDURE break(VAR proc: process; fault: integer);
EXTERNAL;

FUNCTION bufcount(VAR r: reference): integer;
EXTERNAL;

FUNCTION bufsize(VAR r: rtype    ): integer;
BEGIN
bufsize___rc 2 35 2 13 7
END;

FUNCTION bytecount(VAR r: rtype   ): integer;
EXTERNAL;

PROCEDURE chaindequeue(VAR ref: reference; VAR ch: chain);
EXTERNAL;

PROCEDURE chaindown(VAR ch: chain);
EXTERNAL;

PROCEDURE chainenqueue(VAR ref: reference; VAR ch: chain);
EXTERNAL;

FUNCTION chainlength(VAR ch: chain): integer;
BEGIN
chainlength 2 35 2 41 8
END;

PROCEDURE chainreset(VAR ch: chain);
BEGIN
chainreset 1 41 8
END;

PROCEDURE chainstart(VAR ch: chain);
BEGIN
chainstart 1 41 8
END;

PROCEDURE chainup(VAR ch: chain);
EXTERNAL;

FUNCTION ord(v: btype): integer; 
BEGIN
ord 0
END;

FUNCTION ord(v: wtype): integer; AND
FUNCTION chr(v: byte): char;
BEGIN
chr 0
END;


FUNCTION create(inspect incname: string; VAR prog: program_descriptor;
     VAR pr: process; size: integer; prio: integer): create_result;
EXTERNAL;

FUNCTION creditcount(VAR r: reference): integer;
BEGIN
creditcount 2 35 2 13 7
END;

PROCEDURE dec(VAR v: byte);
BEGIN
_dec_byte_rc 1 33 1
END;

PROCEDURE dec(VAR v: integer);
BEGIN
dec 1 33 2
END;

PROCEDURE delay(ms: integer);
BEGIN
delay 1 34 2
END;

FUNCTION eventkind(VAR r: rtype): event_type;
BEGIN
eventkind 2 35 1 13 7
END;

PROCEDURE exception(c: integer);
EXTERNAL;

FUNCTION hometest(VAR r: rtype; VAR p: pool): boolean;
EXTERNAL;

PROCEDURE inc(VAR v: byte);
BEGIN
_inc_byte_rc 1 33 1
END;

PROCEDURE inc(VAR v:integer);
BEGIN
inc 1 33 2
END;

FUNCTION index(VAR r:reference): integer;
BEGIN
index 2 35 2 13 7
END;


FUNCTION link(inspect incname: string;VAR prog: program_descriptor):
              link_result;
EXTERNAL;

FUNCTION locked(VAR m:mailbox): boolean;
BEGIN
locked 2 35 1 9 7
END;

FUNCTION locktest(VAR r: reference): boolean;
BEGIN
locktest 2 35 1 13 7
END;

PROCEDURE new(VAR p: ptype); EXTERNAL;

FUNCTION nil(VAR p:ptype  ): boolean; and
FUNCTION nil(VAR p:process): boolean;
BEGIN
nil 2 35 1 13 7
END;

FUNCTION nil(VAR p:reference): boolean;
BEGIN
nilref 2 35 1 13 7
END;

FUNCTION offset(VAR r:rtype    ): integer; 
BEGIN
offset____rc 2 35 2 13 7
END;

FUNCTION open(VAR m:mailbox): boolean; AND
FUNCTION openpool(VAR p: pool): boolean;
BEGIN
open 2 35 1 9 7
END;

FUNCTION passive(VAR m:mailbox): boolean;
BEGIN
passive 2 35 1 9 7
END;

PROCEDURE pop(VAR b,s: reference);
BEGIN
pop 2 13 7 13 7
END;

FUNCTION pred(v: btype): btype; AND
FUNCTION pred(v: wtype): wtype;
BEGIN
pred 3 35 2 34 2 34 2
END;

PROCEDURE push(VAR b,s: reference);
BEGIN
push 2 13 7 13 7
END;

FUNCTION reason(VAR r:reference): reason_type;
BEGIN
reason 2 35 1 13 7
END;

PROCEDURE release(VAR r: reference);
BEGIN
release 1 13 7
END;

FUNCTION releasepool(VAR p:pool; bufs: integer): integer;
EXTERNAL;

PROCEDURE remove(VAR pr: process);
EXTERNAL;

PROCEDURE resetevent(VAR r: rtype);
BEGIN
resetevent 1 13 7
END;

PROCEDURE resume(VAR pr: process);
EXTERNAL;

PROCEDURE return(VAR r:reference);
BEGIN
return 1 13 7
END;

PROCEDURE setbytecount(VAR r: rtype    ; v: integer);
EXTERNAL;

PROCEDURE setoffset=setoffset_rc(VAR r: rtype    ; v: integer);
EXTERNAL;

PROCEDURE settop=settop____rc(VAR r: rtype    ; v: integer);
EXTERNAL;

PROCEDURE setu1(VAR r: rtype    ; v: byte);
EXTERNAL;

PROCEDURE setu2(VAR r: rtype    ; v: byte);
EXTERNAL;

PROCEDURE setu3(VAR r: rtype    ; v: byte);
EXTERNAL;

PROCEDURE setu4(VAR r: rtype    ; v: byte);
EXTERNAL;

PROCEDURE signal(VAR r: reference; VAR m:mailbox);
BEGIN
signal 2 13 7 9 7
END;

FUNCTION stackdepth(VAR r:reference  ): integer;
EXTERNAL;

PROCEDURE start(VAR pr: process; prio: integer);
EXTERNAL;

PROCEDURE stop(VAR p: process);
EXTERNAL;

FUNCTION succ(v:btype): btype; AND
FUNCTION succ(v:wtype): wtype;
BEGIN
succ 3 35 2 34 2 34 2
END;

PROCEDURE tofrom=tofrom____rc(VAR toref: reference; toindex: integer;
                 VAR fromref: reference; fromindex: integer;
                 bytes: integer );
EXTERNAL;

FUNCTION top(VAR r:rtype    ): integer;
BEGIN
top_______rc 2 35 2 13 7
END;

PROCEDURE trace = exception(f: integer);
EXTERNAL;

PROCEDURE stacktrace = exception(f: integer);
EXTERNAL;

FUNCTION unlink(VAR prog: program_descriptor): integer;
EXTERNAL;

FUNCTION u1(VAR r:rtype    ): byte;
BEGIN
u1 2 35 1 13 7
END;

FUNCTION u2(VAR r:rtype    ): byte;
BEGIN
u2 2 35 1 13 7
END;

FUNCTION u3(VAR r:rtype    ): byte;
BEGIN
u3 2 35 1 13 7
END;

FUNCTION u4(VAR r:rtype    ): byte;
BEGIN
u4 2 35 1 13 7
END;

PROCEDURE wait( VAR r: reference; VAR m: mailbox);
BEGIN
wait 2 13 7 9 7
END;

FUNCTION waitdelay(VAR r: reference; VAR m: mailbox;
                   ms: integer): activation;
EXTERNAL;

PROCEDURE closeport(VAR p: port);
EXTERNAL;

PROCEDURE connect(VAR p:port; index:1..maxint; VAR compl, disc: reference;
                  inspect remote_name:string; service: conn_service);
EXTERNAL;

PROCEDURE disconnect(VAR p:port; index:1..maxint);
EXTERNAL;

PROCEDURE getconnection(VAR p:port; index:1..maxint; VAR compl, disc:reference);
EXTERNAL;

PROCEDURE getcredit(VAR p:port; index:1..maxint; VAR credbuf: reference);
EXTERNAL;

PROCEDURE getreset(VAR p:port; index:1..maxint; VAR indic: reference);
EXTERNAL;

FUNCTION maxconnections:integer;
EXTERNAL;

PROCEDURE openport(VAR p:port; VAR closebuf: reference;
                   inspect name:string; scope: scope_type;
                   no_of_cons: 0..maxint; cntrl: control_type);
EXTERNAL;

PROCEDURE receive(VAR p:port; index:1..maxint; VAR databuf: reference);
EXTERNAL;

PROCEDURE receiveall(VAR p:port; VAR databuf: reference);
EXTERNAL;

PROCEDURE reset(VAR p:port; index:1..maxint; VAR compl: reference);
EXTERNAL;

PROCEDURE send(VAR p:port; index:1..maxint; VAR databuf: reference);
EXTERNAL;


(* Implementation dependent standard routines and types*)

TYPE

coded_date=PACKED RECORD
             year_after_1900: 0..127;
             month: 0..12;
             day: 0..31;
           END;

coded_time=PACKED RECORD
             compiler_version : 0..31;
             hour: 0..23;
             minute: 0..59;
           END;

coded_secs=PACKED RECORD
             sec: 0..59;
             msec: 0..999;
           END;

coded_inc= PACKED RECORD
             days: 0..31;
             hours: 0..23;
             mins: 0..59;
             secs: 0..59;
             msecs: 0..999;
           END;

delaytype= PACKED RECORD
             prev_date: coded_date;
             prev_time: coded_time;
             prev_secs: coded_secs;
             inc : coded_inc;
           END;

clocktype= PACKED RECORD
             date: coded_date;
             time: coded_time;
             secs: coded_secs;
           END;

tversion= RECORD
            release, subrelease: byte;  --  version, issue
          END;

compilerid_type = packed record
     packageidentification   : 0..7;
     compilerrelease         : 0..31;
     compilersubrelease      : 0..255
     end;

(*  package   ident_value  compiler        *)
--   sw2101        1      old rtp35  RC8000
--   sw2104        2      rtp86
--   sw2103        3      rtp35
--   sw2111        4      rtp2111    RC8000
--   sw2114        5      rtp


tmoduleversion= RECORD
                  moduledate: coded_date;
                  moduletime: coded_time;
                  moduleversion: tversion;
                  compilationdate: coded_date;
                  compilationtime: coded_time;
$IF target = rc3502
                  compilerid  : compilerid_type;
$ENDIF
                END;

(*  *)
lookup_descriptor_segment = RECORD
  name             : alfa;
  descriptor_length,
  no_of_pages      ,
  pagesize         ,
  last_page_length ,
  kind             : integer;
  default_appetite ,
  last_param_offset,
  no_of_params     : integer;
  date             : coded_date;
  time             : coded_time;
  source_date      : coded_date;
  source_time      : coded_time;
  version          : integer;
--   $  IF target = rc3502
--   compilerid  : compilerid_type;      --    later ?
--   $  ENDIF
END;

(*  *)

FUNCTION alias( VAR p: port; INSPECT name: string ): boolean;
EXTERNAL;

FUNCTION clock_difference( t1, t2: clocktype ): coded_inc;
EXTERNAL;

FUNCTION clock_increment( t: clocktype; inc: coded_inc ): clocktype;
EXTERNAL;

FUNCTION clock_less_than( t1, t2: clocktype ): boolean;
EXTERNAL;

FUNCTION crc16( op1, op2 : integer ): integer;
BEGIN
crc16 3 35 2 34 2 34 2
END;

FUNCTION crc16buf( VAR r: reference;
  frombyte, tobyte : integer;
  quotient, startvalue : integer ): integer;
EXTERNAL;

FUNCTION deletemailbox(INSPECT mbx_name: string): integer;
EXTERNAL;

FUNCTION getclock: clocktype;
EXTERNAL;

FUNCTION imcpresent: boolean;
EXTERNAL;

PROCEDURE getservers( VAR r: reference; INSPECT mask: string );
EXTERNAL;

FUNCTION namemailbox(VAR m: mailbox; INSPECT mbx_name: string): integer;
EXTERNAL;

FUNCTION ownname(VAR name:string): byte;
EXTERNAL;

FUNCTION ownprogramname(VAR name:string): byte;
EXTERNAL;

PROCEDURE ownversion(var myversion: tmoduleversion);
EXTERNAL;

FUNCTION searchmailbox(INSPECT mbx_name: string): ^mailbox;
EXTERNAL;

PROCEDURE sendadam=sendadam__rc(VAR ref: reference );
EXTERNAL;

PROCEDURE sendlinker=sendlinkerrc(VAR ref: reference );
EXTERNAL;

PROCEDURE sendtimer=sendtimer_rc(VAR ref: reference );
EXTERNAL;

PROCEDURE setownname(INSPECT name: string );
EXTERNAL;

PROCEDURE setpriority(priority : integer);
EXTERNAL;

FUNCTION swap(n: integer): integer;
BEGIN
swap 2 35 2 34 2
END;

(* Implementation demendent open routines *)

--PROCEDURE breakpoint;
--EXTERNAL;

PROCEDURE  definetimer( on: boolean );
EXTERNAL;

--FUNCTION equalhome(VAR a: rtype    ; VAR b: rtype    ): boolean;
--EXTERNAL;

--FUNCTION homeless(VAR r: rtype    ): boolean;
--EXTERNAL;

FUNCTION madd( a, b: integer): integer;
BEGIN
madd 3 35 2 34 2 34 2
END;

FUNCTION mmul( a, b: integer): integer;
BEGIN
mmul 3 35 2 34 2 34 2
END;

FUNCTION msub( a, b: integer): integer;
BEGIN
msub 3 35 2 34 2 34 2
END;

FUNCTION rotate( a, shl: integer): integer;
BEGIN
rotate 3 35 2 34 2 34 2
END;

FUNCTION uadd( a, b: integer): integer;
BEGIN
uadd 3 35 2 34 2 34 2
END;

FUNCTION udiv( a, b: integer): integer;
BEGIN
udiv 3 35 2 34 2 34 2
END;

FUNCTION ult( a, b: integer): boolean;
BEGIN
ult 3 35 1 34 2 34 2
END;

FUNCTION umod( a, b: integer): integer;
BEGIN
umod 3 35 2 34 2 34 2
END;

FUNCTION umul( a, b: integer): integer;
BEGIN
umul 3 35 2 34 2 34 2
END;

FUNCTION usub( a, b: integer): integer;
BEGIN
usub 3 35 2 34 2 34 2
END;


(* INPUT-OUTPUT and INTERRUPT routines *)
PROCEDURE clearinterrupt;
BEGIN
clearinterru 0
END;

PROCEDURE control(c: integer; VAR chmsg: reference);
BEGIN
control 2 34 2 13 7
END;

PROCEDURE controlclr(c: integer);
BEGIN
controlclr 1 34 2
END;

FUNCTION ctrwaitid(c: integer; ms: integer): activation;
BEGIN
ctrwaitid 3 35 1 34 2 34 2
END;

FUNCTION ctrwaitim(c: integer; VAR r: reference; VAR m: mailbox): activation;
BEGIN
ctrwaitim 4 35 1 34 2 13 7 9 7
END;

FUNCTION ctrwaitimd(c: integer; VAR r: reference; VAR m: mailbox;
                   ms: integer ): activation;
BEGIN
ctrwaitimd 5 35 1 34 2 13 7 9 7 34 2
END;

FUNCTION eoi : boolean;
BEGIN
eoi 1 35 1
END;

Type
 bufparamtype =  array ( 1..8 ) of byte;

PROCEDURE getbufparam(VAR bufparam : bufparamtype;
                      first, last: integer; VAR msg: reference);
BEGIN
getbufparam 4 33 8 34 2 34 2 13 7
END;

PROCEDURE inbyteblock( VAR next : integer;
  first, last: integer;
  VAR msg : reference );
BEGIN
inbyteblock 4 33 2 34 2 34 2 13 7
END;

PROCEDURE inword(VAR word: integer; VAR chmsg: reference);
BEGIN
inword 2 33 2 13 7
END;

PROCEDURE inwordblock( VAR next : integer;
  first, last: integer;
  VAR msg : reference );
BEGIN
inmordblock 4 33 2 34 2 34 2 13 7
END;

PROCEDURE inwordclr(VAR word: integer);
BEGIN
inwordclr 1 33 2
END;

PROCEDURE iowbwc(bufparam : bufparamtype);
BEGIN
iowbwc 1 34 8
END;

FUNCTION messagekind( VAR r: reference ): integer;
BEGIN
messagekind 2 35 2 13 7
END;

PROCEDURE outbyteblock( VAR next : integer;
  first, last: integer;
  VAR msg : reference );
BEGIN
outbyteblock 4 33 2 34 2 34 2 13 7
END;

PROCEDURE outword(word : integer; VAR chmsg: reference);
BEGIN
outword 2 34 2 13 7
END;

PROCEDURE outwordblock( VAR next : integer;
  first, last: integer;
  VAR msg : reference );
BEGIN
outwordblock 4 33 2 34 2 34 2 13 7
END;

PROCEDURE outwordclr(word : integer);
BEGIN
outwordclr 1 34 2
END;

PROCEDURE sense(VAR status: integer; status_out : integer;
                VAR chmsg: reference);
BEGIN
sense 3 33 2 34 2 13 7
END;

PROCEDURE senseclr(VAR status: integer; status_out : integer;
                   compare, mask: integer);
BEGIN
senseclr 4 33 2 34 2 34 2 34 2
END;

PROCEDURE setinterrupt(VAR ch : reference);
BEGIN
setinterrupt 1 13 7
END;

FUNCTION timedout: boolean;
BEGIN
timedout 1 35 1
END;

PROCEDURE waiti;
BEGIN
waiti 0
END;

FUNCTION waitid( msecs: integer ): activation;
BEGIN
waitid 2 35 1 34 2
END;

FUNCTION waitim( VAR r: reference; VAR m : mailbox ): activation;
BEGIN
waitim 3 35 1 13 7 9 7
END;

FUNCTION waitimd ( VAR r: reference; VAR m : mailbox;
  msecs : integer ): activation;
BEGIN
waitimd 4 35 1 13 7 9 7 34 2
END;

<*---   removed :

(*             Extra Routines for IMC                        *)
---------------------------------------------------------------

PROCEDURE excptcall ( errno: integer);
BEGIN
excptcall 1 34 2
END;

PROCEDURE signalx(VAR r: reference; VAR m:mailbox);
BEGIN
signalx 2 13 7 9 7
END;

PROCEDURE returnx (VAR r:reference);
BEGIN
returnx 1 13 7
END;

PROCEDURE setcreditcount ( VAR r:reference; credits: byte);
BEGIN
setcreditcou 2 13 7 34 1
END;

PROCEDURE seteventkind ( VAR r:reference; event: event_type);
BEGIN
seteventkind 2 13 7 34 1
END;

PROCEDURE setindex ( VAR r:reference; index: byte);
BEGIN
setindex 2 13 7 34 1
END;

PROCEDURE setreason ( VAR r:reference; reason: reason_type);
BEGIN
setreason 2 13 7 34 1
END;

(*         other useful routines      *)
----------------------------------------

Type
  xmem_no_type =  0..127;

  base_type  = packed record
    mem_no : xmem_no_type;
    nilbit : bit
    end;

  addr = record
   nulbyte : byte;
   base    : base_type;
   disp    : integer
  end;

  adr = record
   base    : base_type;
   disp    : integer
  end;


descriptor_segment = RECORD
  descriptor_length,
  no_of_pages      ,
  pagesize         ,
  last_page_length ,
  kind             : integer;
  name             : alfa;
  entry_point      : addr;
  exception_point  : addr;
  default_appetite ,
  last_param_offset: integer;
  source_date      : coded_date;
  source_time      : coded_time;
  version          : integer;
  compilerid       : compilerid_type;
  no_of_params     : integer;
END;



FUNCTION addptr ( anyptr: ^integer; incr: integer): ^integer;
BEGIN
addptr 3 7 3 6 3 34 2
END;

FUNCTION addrptr ( anyptr: ^integer): addr;
BEGIN
addrptr 2 33 4 6 3
END;

FUNCTION baseinteger ( b: integer) : addr;
BEGIN
baseinteger 2 33 4 34 2
END;

FUNCTION carry : boolean;
BEGIN
carry 1 35 1
END;

PROCEDURE getaddr ( var dest: addr; src: addr);
BEGIN
getaddr 2 33 4 34 4
END;

PROCEDURE getbyte ( var dest: byte; srcaddr: addr);
BEGIN
getbyte 2 33 1 34 4
END;

FUNCTION getid : integer;
BEGIN
getid 1 35 2
END;

PROCEDURE getinteger ( var dest: integer; srcaddr: addr);
BEGIN
getinteger 2 33 2 34 4
END;

PROCEDURE getlfgf ( var lf, gf: addr);
BEGIN
getlfgf 2 33 4 33 4
END;

PROCEDURE getregister ( var dest: integer; index: integer);
BEGIN
getregister 2 33 2 34 2
END;

FUNCTION ptr ( a: byte): ^byte;
BEGIN
ptr 2 7 3 34 1
END;

FUNCTION ptr ( a: integer): ^integer;
BEGIN
ptr 2 7 3 34 2
END;

FUNCTION ptr ( p: ^integer): ^integer;
BEGIN
ptr 2 7 3 34 3
END;

FUNCTION ptr ( a: addr): ^integer;
BEGIN
ptr 2 7 3 34 4
END;

FUNCTION ptraddr ( a: addr): ^integer;
BEGIN
ptraddr 2 7 3 34 4
END;

PROCEDURE putaddr ( a, b: addr);
BEGIN
putaddr 2 34 4 34 4
END;

PROCEDURE readbyte ( var dest, src: byte);
BEGIN
readbyte 2 33 1 33 1
END;

PROCEDURE readram ( var dest: byte; ramindex: integer);
BEGIN
readram 2 33 1 34 2
END;

PROCEDURE readword ( var dest, src: integer);
BEGIN
readword 2 33 2 33 2
END;

FUNCTION ref_mailbox ( var m: mailbox): ^ mailbox;
BEGIN
ref 2 7 3 9 7
END;

PROCEDURE sensembx ( VAR r: reference; VAR m: mailbox);
BEGIN
sensembx 2 13 7 9 7
END;

PROCEDURE writeram ( ramindex, data: integer);
BEGIN
writeram 2 34 2 34 2
END;

---------*>
.