﻿ZZZZ_COPY           	ZZZZ_SQL                 00100	%ZZZZ_SQL_SELECT+REPEAT=_SELECT_COUNT             	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00200	%ZZZZ_SQL_SELECT+SQL=?_SELECT##?                  	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00300	%ZZZZ_SQL_SELECT+REPEAT=                          	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00400	%Z_CANCEL_SELECT+SQL=,X1.Z_CANCEL                 	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00500	%ZZZZ_SQL_FROM+REPEAT=_FROM_COUNT                 	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00600	%ZZZZ_SQL_FROM+SQL=?_FROM##?                      	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00700	%ZZZZ_SQL_FROM+REPEAT=                            	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00800	%ZZZZ_SQL_LEFT+REPEAT=_LEFT_COUNT                 	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 00900	%ZZZZ_SQL_LEFT+SQL=?_LEFT##?                      	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01000	%ZZZZ_SQL_LEFT+REPEAT=                            	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01100	%ZZZZ_SQL_WHERE+REPEAT=_WHERE_COUNT               	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01200	%ZZZZ_SQL_WHERE+SQL=?_WHERE##?                    	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01300	%ZZZZ_SQL_WHERE+REPEAT=                           	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01400	%Z_CANCEL_WHERE+SQL=?_WHERE_AND? X1.Z_CANCEL=' '  	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01500	%ZZZZ_SQL_GROUP+REPEAT=_GROUP_COUNT               	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01600	%ZZZZ_SQL_GROUP+SQL=?_GROUP##?                    	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01700	%ZZZZ_SQL_GROUP+REPEAT=                           	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01800	%ZZZZ_SQL_HAVING+SQL=?_HAVING?                    	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 01900	%ZZZZ_SQL_ORDER+REPEAT=_ORDER_COUNT               	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 02000	%ZZZZ_SQL_ORDER+SQL=?_ORDER##?                    	                                                  
ZZZZ_COPY           	ZZZZ_SQL                 02100	%ZZZZ_SQL_ORDER+REPEAT=                           	                                                  
ZZZZ_PROGRAM        	//$(NUMBER)+//               1	$1+(REPEAT2=)                                     	//                                                
ZZZZ_PROGRAM        	//%(NAME)+//                 1	%(NAME)+                                          	//                                                
ZZZZ_PROGRAM        	//(NUMBER)+//                1	1+(REPEAT=)                                       	//                                                
ZZZZ_PROGRAM        	//*//                        1	*(コメント）                                           	//                                                
ZZZZ_PROGRAM        	//=BACK//                    1	=BACK{(TAG)};                                     	//                                                
ZZZZ_PROGRAM        	//=BAT_SERVER//              1	=BAT_SERVER{(FILE)}{[,(OPTION)]};                 	T/                                                
ZZZZ_PROGRAM        	//=BEEP//                    1	=BEEP{};                                          	M/                                                
ZZZZ_PROGRAM        	//=COMMAND//                 1	=COMMAND{(COMMAND) [,(OPTION)]};                  	M/                                                
ZZZZ_PROGRAM        	//=COMPUTE//                 1	=COMPUTE{X1.~~_XXX=X1.~~_YYY+X1.~~_ZZZ,..};       	//                                                
ZZZZ_PROGRAM        	//=COMPUTE//                 2	=COMPUTE{X1.~~_XXX+=X1.~~_YYY,..};                	//                                                
ZZZZ_PROGRAM        	//=COMPUTE_CUT//             1	=COMPUTE_CUT{X1.~~_XXX=X1.~~_YYY+X1.~~_ZZZ,..};   	//                                                
ZZZZ_PROGRAM        	//=COMPUTE_CUT//             2	=COMPUTE_CUT{X1.~~_XXX+=X1.~~_YYY,..};            	//                                                
ZZZZ_PROGRAM        	//=COPY_FILE//               1	=COPY_FILE{(OUTPUT FILE)}                         	M/                                                
ZZZZ_PROGRAM        	//=COPY_FILE//               2	=  {(INPUT FILE)};                                	M*                                                
ZZZZ_PROGRAM        	//=COPY_TABLE//              1	=COPY_TABLE{?_WORK_TABLE?A}                       	//                                                
ZZZZ_PROGRAM        	//=COPY_TABLE//              2	=  {?_M?_XXX_TABLE}{(NULL OR NOT OR SQL)};        	/*                                                
ZZZZ_PROGRAM        	//=CREATE_INDEX//            1	=CREATE_INDEX{?_WORK_TABLE?A}{0-9}                	//                                                
ZZZZ_PROGRAM        	//=CREATE_INDEX//            2	=  {~~_KEY1,~~_KEY2}{[,UNIQUE]};                  	/*                                                
ZZZZ_PROGRAM        	//=CREATE_OBJECT//           1	=CREATE_OBJECT{(OBJECT)}{[VIEW,FUNC,PROC,TRIG]}   	//                                                
ZZZZ_PROGRAM        	//=CREATE_OBJECT//           2	=  {(DEFINE)};                                    	/*                                                
ZZZZ_PROGRAM        	//=CREATE_TABLE//            1	=CREATE_TABLE{?_WORK_TABLE?A}                     	//                                                
ZZZZ_PROGRAM        	//=CREATE_TABLE//            2	=  {~~_KEY1,*,~~_KEY2,*}                          	/*                                                
ZZZZ_PROGRAM        	//=CREATE_TABLE//            3	=  {~~_DATA1,*,~~_DATA2,*};                       	/*                                                
ZZZZ_PROGRAM        	//=CREATE_TABLE2//           1	=CREATE_TABLE2{?_WORK_TABLE?A}                    	//                                                
ZZZZ_PROGRAM        	//=CREATE_TABLE2//           2	=  {~~_KEY1,*,~~_KEY2,*}                          	/*                                                
ZZZZ_PROGRAM        	//=CREATE_TABLE2//           3	=  {~~_DATA1,*,~~_DATA2,*};                       	/*                                                
ZZZZ_PROGRAM        	//=DIR//                     1	=DIR{(DIRECTORY)}ERROR{};                         	//                                                
ZZZZ_PROGRAM        	//=DIR//                     2	=NEXT:DIR_NEXT{W.~~_DIR}JUMP{END};                	//                                                
ZZZZ_PROGRAM        	//=DIR//                     3	=;;;                                              	/*                                                
ZZZZ_PROGRAM        	//=DIR//                     4	=BACK{NEXT};                                      	/*                                                
ZZZZ_PROGRAM        	//=DIR//                     5	=END:                                             	/*                                                
ZZZZ_PROGRAM        	//=DIR_DIR//                 1	=DIR_DIR{(DIRECTORY)}ERROR{};                     	//                                                
ZZZZ_PROGRAM        	//=DIR_DIR//                 2	=NEXT:DIR_DIR_NEXT{W.~~_DIRECTORY}JUMP{END};      	//                                                
ZZZZ_PROGRAM        	//=DIR_DIR//                 3	=;;;                                              	/*                                                
ZZZZ_PROGRAM        	//=DIR_DIR//                 4	=BACK{NEXT};                                      	/*                                                
ZZZZ_PROGRAM        	//=DIR_DIR//                 5	=END:                                             	/*                                                
ZZZZ_PROGRAM        	//=DROP_INDEX//              1	=DROP_INDEX{?_WORK_TABLE?A}{0-9};                 	//                                                
ZZZZ_PROGRAM        	//=DROP_OBJECT//             1	=DROP_OBJECT{(OBJECT)}{[VIEW,FUNC,PROC,TRIG]};    	//                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              1	BEGIN_END                                         	M*                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              2	NAME=DROP_TABLE                                   	T*                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              3	REPEAT=?_A_A?                                     	/*                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              4	=DROP_TABLE{?_WORK_TABLE??_A##?};                 	//                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              5	REPEAT=                                           	/*                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              6	NAME=                                             	T*                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              7	=;;;                                              	T*                                                
ZZZZ_PROGRAM        	//=DROP_TABLE//              8	COPY=DROP_TABLE                                   	T*                                                
ZZZZ_PROGRAM        	//=ERASE_FILE//              1	=ERASE_FILE{(FILE)};                              	//                                                
ZZZZ_PROGRAM        	//=ERROR//                   1	=ERROR{[,(MESSAGE)]};                             	//                                                
ZZZZ_PROGRAM        	//=EXE//                     1	=EXE{(PROGRAM.EXE)}{[,(OPTION)]};                 	M/                                                
ZZZZ_PROGRAM        	//=EXE_I//                   1	=EXE_I{(JOB)}{[,(OPTION)]};                       	M/                                                
ZZZZ_PROGRAM        	//=EXE_WAIT//                1	=EXE_WAIT{(PROGRAM.EXE)}{[,(OPTION)]}             	M/                                                
ZZZZ_PROGRAM        	//=EXIT//                    1	=EXIT{[,(NAME),_END,+1,-(NUMBER),(NUMBER)]};      	M/                                                
ZZZZ_PROGRAM        	//=EXIT//                    2	=EXIT{};                                          	T/                                                
ZZZZ_PROGRAM        	//=EXIT2//                   1	=EXIT2{(NAME)};                                   	M/                                                
ZZZZ_PROGRAM        	//=EXIT3//                   1	=EXIT3{(NAME)};                                   	M/                                                
ZZZZ_PROGRAM        	//=GRANT//                   1	=GRANT{(OBJECCT)}                                 	//                                                
ZZZZ_PROGRAM        	//=GRANT//                   2	=  {[TABLE,VIEW,FUNC,PROC,TRIG]}{[,PUBLIC,LINK]}; 	/*                                                
ZZZZ_PROGRAM        	//=GRANT_PERMISSION//        1	=GRANT_PERMISSION{(OBJECT)}                       	//                                                
ZZZZ_PROGRAM        	//=GRANT_PERMISSION//        2	=  {[TABLE,VIEW,FUNC,PROC,TRIG]}                  	/*                                                
ZZZZ_PROGRAM        	//=GRANT_PERMISSION//        3	=  {(ZZZY)}{[,LINK]};                             	/*                                                
ZZZZ_PROGRAM        	//=IF//                      1	=IF{X1.~~_XXX=X1.~~_YYY,X1.~~_XXX=X1.~~_ZZZ}...;  	//                                                
ZZZZ_PROGRAM        	//=IF_FILE//                 1	=IF_FILE{(FILE)}...;                              	//                                                
ZZZZ_PROGRAM        	//=IF_NAME//                 1	=IF_NAME{(DATA)}...;                              	//                                                
ZZZZ_PROGRAM        	//=IF_TABLE//                1	=IF_TABLE{?_WORK_TABLE?A}...;                     	//                                                
ZZZZ_PROGRAM        	//=INSERT//                  1	=INSERT{?_WORK_TABLE?A}                           	//                                                
ZZZZ_PROGRAM        	//=INSERT//                  2	=  {W.~~_XXX,W.~~_YYY};                           	/*                                                
ZZZZ_PROGRAM        	//=INSERT_FILE//             1	=INSERT_FILE{?_WORK_TABLE?A}                      	//                                                
ZZZZ_PROGRAM        	//=INSERT_FILE//             2	=  {~~_XXX,~~_YYY}                                	/*                                                
ZZZZ_PROGRAM        	//=INSERT_FILE//             3	=  {(FILE)}{[,UTF-8,SHIFT_JIS,EUC-JP,/};          	/*                                                
ZZZZ_PROGRAM        	//=JUMP//                    1	=JUMP{(TAG)};                                     	//                                                
ZZZZ_PROGRAM        	//=LINK_SET//                1	=LINK_SET{W.~~_LINK}                              	//                                                
ZZZZ_PROGRAM        	//=LINK_SET//                2	=  {(SELECT ... FROM)}                            	/*                                                
ZZZZ_PROGRAM        	//=LINK_SET//                3	=  {(TABLE)}{X1}                                  	/*                                                
ZZZZ_PROGRAM        	//=LINK_SET//                4	=  {(WHERE ...)};                                 	/*                                                
ZZZZ_PROGRAM        	//=MESSAGE//                 1	=MESSAGE{MESSAGE};                                	//                                                
ZZZZ_PROGRAM        	//=NOP//                     1	=NOP{};                                           	//                                                
ZZZZ_PROGRAM        	//=OUTPUT//                  1	=OUTPUT{W.~~_XXX,W.~~_YYY};                       	//                                                
ZZZZ_PROGRAM        	//=OUTPUT_CLEAR//            1	=OUTPUT_CLEAR{};                                  	//                                                
ZZZZ_PROGRAM        	//=PROGRAM//                 1	=PROGRAM{?_M?_XXX_TABLE}                          	//                                                
ZZZZ_PROGRAM        	//=PROGRAM//                 2	=  {W.~~_KEY1,W.~~_KEY2}                          	/*                                                
ZZZZ_PROGRAM        	//=PROGRAM//                 3	=  {W.~~_DATA1,W.~~_DAT2}{[0,1,2,3][,N,E,P,PE]};  	/*                                                
ZZZZ_PROGRAM        	//=PROGRAM2//                1	=PROGRAM2{?_M?_XXX_TABLE}                         	//                                                
ZZZZ_PROGRAM        	//=PROGRAM2//                2	=  {W.~~_KEY1,W.~~_KEY2}                          	/*                                                
ZZZZ_PROGRAM        	//=PROGRAM2//                3	=  {W.~~_DATA1,W.~~_DAT2}{[0,1,2,3][,N,E,P,PE]};  	/*                                                
ZZZZ_PROGRAM        	//=READ1//                   1	=READ1_OPEN{(FILE)}{[,UTF-8,SHIFT_JIS,/]}ERROR{}; 	//                                                
ZZZZ_PROGRAM        	//=READ1//                   2	=NEXT:READ1_NEXT{W.~~_XXX,W.~~_YYY}JUMP{END};     	//                                                
ZZZZ_PROGRAM        	//=READ1//                   3	=;;;                                              	/*                                                
ZZZZ_PROGRAM        	//=READ1//                   4	=BACK{NEXT};                                      	/*                                                
ZZZZ_PROGRAM        	//=READ1//                   5	=END:READ1_CLOSE{};                               	//                                                
ZZZZ_PROGRAM        	//=READ2//                   1	=READ2_OPEN{(FILE)}{[,UTF-8,SHIFT_JIS,/]}ERROR{}; 	//                                                
ZZZZ_PROGRAM        	//=READ2//                   2	=NEXT:READ2_NEXT{W.~~_XXX,W.~~_YYY}JUMP{END};     	//                                                
ZZZZ_PROGRAM        	//=READ2//                   3	=;;;                                              	/*                                                
ZZZZ_PROGRAM        	//=READ2//                   4	=BACK{NEXT};                                      	/*                                                
ZZZZ_PROGRAM        	//=READ2//                   5	=END:READ2_CLOSE{};                               	//                                                
ZZZZ_PROGRAM        	//=RECEIVE//                 1	=RECEIVE{(NUMBER)};                               	M/                                                
ZZZZ_PROGRAM        	//=RECEIVE_BEEP//            1	=RECEIVE_BEEP{(NUMBER)};                          	M/                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL//             1	=REPLACE_ALL{?_M?_XXX_TABLE}                      	//                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL//             2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL//             3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL//             4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL//             5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL2//            1	=REPLACE_ALL2{?_M?_XXX_TABLE}                     	//                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL2//            2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL2//            3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL2//            4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_ALL2//            5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART//            1	=REPLACE_PART{?_M?_XXX_TABLE}                     	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART//            2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART//            3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART//            4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART//            5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD//        1	=REPLACE_PART_ADD{?_M?_XXX_TABLE}                 	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD//        2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD//        3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD//        4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD//        5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD2//       1	=REPLACE_PART_ADD2{?_M?_XXX_TABLE}                	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD2//       2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD2//       3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD2//       4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_ADD2//       5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CANCEL//     1	=REPLACE_PART_CANCEL{?_M?_XXX_TABLE}              	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CANCEL//     2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CANCEL//     3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CANCEL//     4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CANCEL//     5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE//     1	=REPLACE_PART_CHANGE{?_M?_XXX_TABLE}              	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE//     2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE//     3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE//     4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE//     5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE2//    1	=REPLACE_PART_CHANGE2{?_M?_XXX_TABLE}             	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE2//    2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE2//    3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE2//    4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART_CHANGE2//    5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART2//           1	=REPLACE_PART2{?_M?_XXX_TABLE}                    	//                                                
ZZZZ_PROGRAM        	//=REPLACE_PART2//           2	=  {?_WORK_TABLE?A}                               	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART2//           3	=  {~~_KEY1,~~_KEY2}                              	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART2//           4	=  {~~_DATA1,~~_DATA2}                            	/*                                                
ZZZZ_PROGRAM        	//=REPLACE_PART2//           5	=  {[,(OUTPUT WHERE)]}{[,(INPUT WHERE)]};         	/*                                                
ZZZZ_PROGRAM        	//=REVOKE_PERMISSION//       1	=REVOKE_PERMISSION{(OBJECT)}                      	//                                                
ZZZZ_PROGRAM        	//=REVOKE_PERMISSION//       2	=  {[TABLE,VIEW,FUNC,PROC,TRIG]}                  	/*                                                
ZZZZ_PROGRAM        	//=REVOKE_PERMISSION//       3	=  {(ZZZY)}{[,LINK]};                             	/*                                                
ZZZZ_PROGRAM        	//=SEND//                    1	=SEND{1-89}{(COMPUTER1);(COMPUTER2)}              	//                                                
ZZZZ_PROGRAM        	//=SEND//                    2	=  {(MESSAGE)};                                   	/*                                                
ZZZZ_PROGRAM        	//=SERIALPORT1//             1	=SERIALPORT1_OPEN{COM1,9600,NONE,8,ONE}           	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT1//             2	=  {[,UTF-8,SHIFT_JIS,EUC-JP]}ERROR{};            	/*                                                
ZZZZ_PROGRAM        	//=SERIALPORT1//             3	=SERIALPORT1_READ{X1.~~_XXX}{(COUNT)}             	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT1//             4	=SERIALPORT1_WRITE{X1.~~_XXX}                     	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT1//             5	=SERIALPORT1_CLOSE{}                              	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT2//             1	=SERIALPORT1_OPEN{COM1,9600,NONE,8,ONE}           	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT2//             2	=  {[,UTF-8,SHIFT_JIS,EUC-JP]}ERROR{};            	/*                                                
ZZZZ_PROGRAM        	//=SERIALPORT2//             3	=SERIALPORT1_READ{X1.~~_XXX}{(COUNT)}             	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT2//             4	=SERIALPORT1_WRITE{X1.~~_XXX}                     	//                                                
ZZZZ_PROGRAM        	//=SERIALPORT2//             5	=SERIALPORT1_CLOSE{}                              	//                                                
ZZZZ_PROGRAM        	//=SERVER_BAT//              1	=SERVER_BAT{(FILE)}{[,(OPTION)]};                 	//                                                
ZZZZ_PROGRAM        	//=SERVER_GET//              1	=SERVER_GET{[,(PATH)]}{(FILE)};                   	//                                                
ZZZZ_PROGRAM        	//=SERVER_PUT//              1	=SERVER_PUT{(FILE)};                              	//                                                
ZZZZ_PROGRAM        	//=SET//                     1	=SET{X1.~~_XXX[+]=X1.~~_YYY[+X1.~~_ZZZ],..};      	//                                                
ZZZZ_PROGRAM        	//=SET_DICTIONARY//          1	=SET_DICTIONARY{~~_XXX,~~_YYY};                   	//                                                
ZZZZ_PROGRAM        	//=SET_TABLE//               1	=SET_TABLE{&X2}{?_M?_XXX_TABLE};                  	//                                                
ZZZZ_PROGRAM        	//=SLEEP//                   1	=SLEEP{(SEC)};                                    	//                                                
ZZZZ_PROGRAM        	//=SMTP//                    1	=SMTP{(SERVER)}{(PORT)}{(TO);(TO)}                	//                                                
ZZZZ_PROGRAM        	//=SMTP//                    2	=  {(FROM)}{(SUB)}{(MESSAGE)};                    	/*                                                
ZZZZ_PROGRAM        	//=SPLIT_CHAR//              1	=SPLIT_CHAR{W_SPLIT_}{(STRING)}{(CHAR)};          	//                                                
ZZZZ_PROGRAM        	//=SPLIT_FORM//              1	=SPLIT_FORM{W_SPLIT_}{(STRING)}{(LENGTH)};        	//                                                
ZZZZ_PROGRAM        	//=SQL//                     1	=SQL{(SQL)};                                      	//                                                
ZZZZ_PROGRAM        	//=SQL_FILE//                1	=SQL_FILE{(FILE(ADD))}{[,OT,ADD]}                 	//                                                
ZZZZ_PROGRAM        	//=SQL_FILE//                2	=  {[,UTF-8,SHIFT_JIS,EUC-JP,/][,W,U]}{(SQL)};    	/*                                                
ZZZZ_PROGRAM        	//=SQL_FILE2//               1	=SQL_FILE2{(FILE)}{[,OT,ADD]}                     	//                                                
ZZZZ_PROGRAM        	//=SQL_FILE2//               2	=  {[,UTF-8,SHIFT_JIS,EUC-JP,/][,W,U]}{(SQL)};    	/*                                                
ZZZZ_PROGRAM        	//=SQL_REAL_TEST//           1	=SQL_REAL_TEST{(SQL)};                            	//                                                
ZZZZ_PROGRAM        	//=SQL_SET//                 1	=SQL_SET{X1.~~_XXX,X1.~~_YYY}{(SQL)}...;          	//                                                
ZZZZ_PROGRAM        	//=SQL1//                    1	=SQL1{(SQL)};                                     	//                                                
ZZZZ_PROGRAM        	//=SQL1//                    2	=NEXT:SQL1_NEXT{W.~~_XXX,W.~~_YYY}JUMP{END};      	//                                                
ZZZZ_PROGRAM        	//=SQL1//                    3	=;;;                                              	/*                                                
ZZZZ_PROGRAM        	//=SQL1//                    4	=BACK{NEXT};                                      	/*                                                
ZZZZ_PROGRAM        	//=SQL1//                    5	=END:                                             	/*                                                
ZZZZ_PROGRAM        	//=SQL1_FIRST//              1	=SQL1_FIRST{};                                    	//                                                
ZZZZ_PROGRAM        	//=SQL2//                    1	=SQL2{(SQL)};                                     	//                                                
ZZZZ_PROGRAM        	//=SQL2//                    2	=NEXT:SQL2_NEXT{W.~~_XXX,W.~~_YYY}JUMP{END};      	//                                                
ZZZZ_PROGRAM        	//=SQL2//                    3	=;;;                                              	/*                                                
ZZZZ_PROGRAM        	//=SQL2//                    4	=BACK{NEXT};                                      	/*                                                
ZZZZ_PROGRAM        	//=SQL2//                    5	=END:                                             	/*                                                
ZZZZ_PROGRAM        	//=SQL2_FIRST//              1	=SQL2_FIRST{};                                    	//                                                
ZZZZ_PROGRAM        	//=TIMER//                   1	=TIMER{(SEC)};                                    	M/                                                
ZZZZ_PROGRAM        	//=TIMER_BEEP//              1	=TIMER_BEEP{(SEC)};                               	M/                                                
ZZZZ_PROGRAM        	//=UPDATE//                  1	=UPDATE{?_M?_XXX_TABLE}                           	//                                                
ZZZZ_PROGRAM        	//=UPDATE//                  2	=  {~~_XXX,~~_YYY}                                	/*                                                
ZZZZ_PROGRAM        	//=UPDATE//                  3	=  {X1.~~_XXX,X1.~~_YYY}                          	/*                                                
ZZZZ_PROGRAM        	//=UPDATE//                  4	=  {?_M?_YYY_TABLE ...};                          	/*                                                
ZZZZ_PROGRAM        	//=WRITE1//                  1	=WRITE1_OPEN{(FILE)}{[OT,ADD]}                    	//                                                
ZZZZ_PROGRAM        	//=WRITE1//                  2	=  {[,UTF-8,SHIFT_JIS,EUC-JP,/][,W,U]}ERROR{};    	/*                                                
ZZZZ_PROGRAM        	//=WRITE1//                  3	=WRITE1{X1.~~_XXX,X1.~~_YYY};                     	//                                                
ZZZZ_PROGRAM        	//=WRITE1//                  4	=WRITE1_CLOSE{};                                  	//                                                
ZZZZ_PROGRAM        	//=WRITE2//                  1	=WRITE2_OPEN{(FILE)}{[OT,ADD]}                    	//                                                
ZZZZ_PROGRAM        	//=WRITE2//                  2	=  {[,UTF-8,SHIFT_JIS,EUC-JP,/][,W,U]}ERROR{};    	/*                                                
ZZZZ_PROGRAM        	//=WRITE2//                  3	=WRITE2{X1.~~_XXX,X1.~~_YYY};                     	//                                                
ZZZZ_PROGRAM        	//=WRITE2//                  4	=WRITE2_CLOSE{};                                  	//                                                
ZZZZ_PROGRAM        	//BEGIN//                    1	BEGIN                                             	M/                                                
ZZZZ_PROGRAM        	//BEGIN_END//                2	BEGIN_END                                         	M/                                                
ZZZZ_PROGRAM        	//CHECK1=//                  1	CHECK1=XXX,YYY,(XXX,YYY)                          	M/                                                
ZZZZ_PROGRAM        	//CHECK2=//                  1	CHECK2=XXX,YYY                                    	M/                                                
ZZZZ_PROGRAM        	//CLICK=//                   1	CLICK=(OPARATION)                                 	M/                                                
ZZZZ_PROGRAM        	//COLOR//                    1	COLOR                                             	M/                                                
ZZZZ_PROGRAM        	//COMMENT_BEGIN//            1	COMMENT_BEGIN                                     	//                                                
ZZZZ_PROGRAM        	//COMMENT_END//              1	COMMENT_END                                       	//                                                
ZZZZ_PROGRAM        	//CONTROL=//                 1	CONTROL=BEGIN_ENTER,0,1,2,3,SCROLL,WIDTH,MAX      	//                                                
ZZZZ_PROGRAM        	//CONTROL=//                 2	CONTROL=JUDGE,ERROR,ERROR_SQL,PROGRAM_ERROR       	//                                                
ZZZZ_PROGRAM        	//CONTROL=//                 3	CONTROL=PROGRAM,PROGRAM_TEST,1_TABLE,2_KEY        	//                                                
ZZZZ_PROGRAM        	//COPY=//                    1	COPY=(NAME)                                       	//                                                
ZZZZ_PROGRAM        	//DATA=//                    1	DATA={*O}X2.?&X2.DATA&~~_XXX?                     	M/                                                
ZZZZ_PROGRAM        	//DICTIONARY=//              1	DICTIONARY=~~_DATA1,~~_DATA2                      	//                                                
ZZZZ_PROGRAM        	//EN+//                      1	EN+(ENGLSH)                                       	//                                                
ZZZZ_PROGRAM        	//END//                      1	END                                               	M/                                                
ZZZZ_PROGRAM        	//FORM0=//                   1	FORM0=(LEFT FORM AND REPEAT START)                	M/                                                
ZZZZ_PROGRAM        	//FORM1=//                   1	FORM1=(LEFT FORM)                                 	M/                                                
ZZZZ_PROGRAM        	//FORM2=//                   1	FORM2=(RIGHT FORM)                                	M/                                                
ZZZZ_PROGRAM        	//FROM=//                    1	PROGRAM=&X1,?_M?_XXX_TABLE                        	T/                                                
ZZZZ_PROGRAM        	//FULL=//                    1	FULL=&X2,?_M?_YYY_TABLE,&X1,0-9                   	//                                                
ZZZZ_PROGRAM        	//FULL2=//                   1	FULL2=&X2,?_M?_YYY_TABLE,&X1,0-9                  	//                                                
ZZZZ_PROGRAM        	//I+//                       1	I+(IBM DB2)                                       	//                                                
ZZZZ_PROGRAM        	//INNER=//                   1	INNER=&X2,?_M?_YYY_TABLE,&X1,0-9                  	//                                                
ZZZZ_PROGRAM        	//INNER2=//                  1	INNER2=&X2,?_M?_YYY_TABLE,&X1,0-9                 	//                                                
ZZZZ_PROGRAM        	//INPUT+//                   1	INPUT+                                            	M/                                                
ZZZZ_PROGRAM        	//JA+//                      1	JA+(JAPANESE)                                     	//                                                
ZZZZ_PROGRAM        	//JOIN_KEY=//                1	JOIN_KEY=~~_DATA1,~~_DATA2                        	//                                                
ZZZZ_PROGRAM        	//JOIN_ON=//                 1	JOIN_ON=(JOIN ON LOGIC)                           	//                                                
ZZZZ_PROGRAM        	//LEFT=//                    1	LEFT=&X2,?_M?_YYY_TABLE,&X1,0-9                   	//                                                
ZZZZ_PROGRAM        	//LEFT2=//                   1	LEFT2=&X2,?_M?_YYY_TABLE,&X1,0-9                  	//                                                
ZZZZ_PROGRAM        	//LINE=//                    1	LINE=(COUNT)                                      	M/                                                
ZZZZ_PROGRAM        	//M+//                       1	M+(MSSQL)                                         	//                                                
ZZZZ_PROGRAM        	//MEAASGE=//                 1	MESSAGE=(MESSAGE)                                 	M/                                                
ZZZZ_PROGRAM        	//MENU_INPUT+//              1	MENU_INPUT+                                       	M/                                                
ZZZZ_PROGRAM        	//MENU_OUTPUT+//             1	MENU_OUTPUT+                                      	M/                                                
ZZZZ_PROGRAM        	//MINUS=//                   1	MINUS=%(NAME)                                     	//                                                
ZZZZ_PROGRAM        	//NAME=//                    1	NAME=[,(NAME)]                                    	//                                                
ZZZZ_PROGRAM        	//NAME2=//                   1	NAME2=[,(NAME)]                                   	//                                                
ZZZZ_PROGRAM        	//NOT+//                     1	NOT+                                              	M/                                                
ZZZZ_PROGRAM        	//O+//                       1	O+(ORACLE)                                        	//                                                
ZZZZ_PROGRAM        	//OUTPUT+//                  1	OUTPUT+                                           	M/                                                
ZZZZ_PROGRAM        	//P+//                       1	P+(POSTGRESQL)                                    	//                                                
ZZZZ_PROGRAM        	//PLUS=//                    1	PLUS=%(NAME)                                      	//                                                
ZZZZ_PROGRAM        	//PROGRAM=//                 1	PROGRAM=,&X1,?_M?_XXX_TABLE                       	M/                                                
ZZZZ_PROGRAM        	//REPEAT=//                  1	REPEAT=[,(END)],[,(START)]                        	//                                                
ZZZZ_PROGRAM        	//REPEAT2=//                 1	REPEAT2=[,(END)],[,(START)]                       	//                                                
ZZZZ_PROGRAM        	//RIGHT=//                   1	RIGHT=&X2,?_M?_YYY_TABLE,&X1,0-9                  	//                                                
ZZZZ_PROGRAM        	//RIGHT2=//                  1	RIGHT2=&X2,?_M?_YYY_TABLE,&X1,0-9                 	//                                                
ZZZZ_PROGRAM        	//SET=//                     1	SET={}SX2.?&X2.SET&~~_XXX?                        	M/                                                
ZZZZ_PROGRAM        	//SQL=//                     1	%ZZZZ_SQL_SELECT+REPEAT=_SELECT_COUNT             	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     2	%ZZZZ_SQL_SELECT+SQL=?_SELECT##?                  	M/                                                
ZZZZ_PROGRAM        	//SQL=//                     3	%ZZZZ_SQL_SELECT+REPEAT=                          	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     4	%Z_CANCEL_SELECT+SQL=,X1.Z_CANCEL                 	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     5	%ZZZZ_SQL_FROM+REPEAT=_FROM_COUNT                 	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     6	%ZZZZ_SQL_FROM+SQL=?_FROM##?                      	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     7	%ZZZZ_SQL_FROM+REPEAT=                            	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     8	%ZZZZ_SQL_LEFT+REPEAT=_LEFT_COUNT                 	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     9	%ZZZZ_SQL_LEFT+SQL=?_LEFT##?                      	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     A	%ZZZZ_SQL_LEFT+REPEAT=                            	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     B	%ZZZZ_SQL_WHERE+REPEAT=_WHERE_COUNT               	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     C	%ZZZZ_SQL_WHERE+SQL=?_WHERE##?                    	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     D	%ZZZZ_SQL_WHERE+REPEAT=                           	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     E	%Z_CANCEL_WHERE+SQL=?_WHERE_AND? X1.Z_CANCEL=' '  	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     F	%ZZZZ_SQL_GROUP+REPEAT=_GROUP_COUNT               	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     G	%ZZZZ_SQL_GROUP+SQL=?_GROUP##?                    	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     H	%ZZZZ_SQL_GROUP+REPEAT=                           	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     I	%ZZZZ_SQL_HAVING+SQL=?_HAVING?                    	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     J	%ZZZZ_SQL_ORDER+REPEAT=_ORDER_COUNT               	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     K	%ZZZZ_SQL_ORDER+SQL=?_ORDER##?                    	M*                                                
ZZZZ_PROGRAM        	//SQL=//                     L	%ZZZZ_SQL_ORDER+REPEAT=                           	M*                                                
ZZZZ_PROGRAM        	//START//                    1	START                                             	M/                                                
ZZZZ_PROGRAM        	//STOP_AFTER//               1	STOP_AFTER                                        	M/                                                
ZZZZ_PROGRAM        	//STOP_BEFORE//              1	STOP_BEFORE                                       	M/                                                
ZZZZ_PROGRAM        	//TABLE=//                   1	TABLE=&X2,?_M?_YYY_TABLE                          	//                                                
ZZZZ_PROGRAM        	//TEST+//                    1	TEST+                                             	//                                                
ZZZZ_PROGRAM        	//TITLE=//                   1	TITLE=(TITLE)                                     	M/                                                
ZZZZ_PROGRAM        	//U+//                       1	U+(UNIX)                                          	//                                                
ZZZZ_PROGRAM        	//W+//                       1	W+(WINDOWS)                                       	//                                                
ZZZZ_PROGRAM        	//WORK=//                    1	WORK=W.?&X2.DATA&X1.~~_XXX?                       	//                                                
