set head off
set pagesize 0
set echo on
create table t2 (name varchar(30),result varchar(2));

create procedure f1 as begin goto ACCESSIBLE; null;<<ACCESSIBLE>> null; end;
/
insert into t2 values ('ACCESSIBLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ACCESSIBLE';
commit;
drop procedure f1;

create procedure f1 as begin goto ACTION; null;<<ACTION>> null; end;
/
insert into t2 values ('ACTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ACTION';
commit;
drop procedure f1;

create procedure f1 as begin goto ADD; null;<<ADD>> null; end;
/
insert into t2 values ('ADD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ADD';
commit;
drop procedure f1;

create procedure f1 as begin goto ADMIN; null;<<ADMIN>> null; end;
/
insert into t2 values ('ADMIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ADMIN';
commit;
drop procedure f1;

create procedure f1 as begin goto AFTER; null;<<AFTER>> null; end;
/
insert into t2 values ('AFTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AFTER';
commit;
drop procedure f1;

create procedure f1 as begin goto AGAINST; null;<<AGAINST>> null; end;
/
insert into t2 values ('AGAINST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AGAINST';
commit;
drop procedure f1;

create procedure f1 as begin goto AGGREGATE; null;<<AGGREGATE>> null; end;
/
insert into t2 values ('AGGREGATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AGGREGATE';
commit;
drop procedure f1;

create procedure f1 as begin goto ALL; null;<<ALL>> null; end;
/
insert into t2 values ('ALL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ALL';
commit;
drop procedure f1;

create procedure f1 as begin goto ALGORITHM; null;<<ALGORITHM>> null; end;
/
insert into t2 values ('ALGORITHM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ALGORITHM';
commit;
drop procedure f1;

create procedure f1 as begin goto ALTER; null;<<ALTER>> null; end;
/
insert into t2 values ('ALTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ALTER';
commit;
drop procedure f1;

create procedure f1 as begin goto ALWAYS; null;<<ALWAYS>> null; end;
/
insert into t2 values ('ALWAYS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ALWAYS';
commit;
drop procedure f1;

create procedure f1 as begin goto ANALYZE; null;<<ANALYZE>> null; end;
/
insert into t2 values ('ANALYZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ANALYZE';
commit;
drop procedure f1;

create procedure f1 as begin goto AND; null;<<AND>> null; end;
/
insert into t2 values ('AND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AND';
commit;
drop procedure f1;

create procedure f1 as begin goto ANY; null;<<ANY>> null; end;
/
insert into t2 values ('ANY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ANY';
commit;
drop procedure f1;

create procedure f1 as begin goto AS; null;<<AS>> null; end;
/
insert into t2 values ('AS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AS';
commit;
drop procedure f1;

create procedure f1 as begin goto ASC; null;<<ASC>> null; end;
/
insert into t2 values ('ASC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ASC';
commit;
drop procedure f1;

create procedure f1 as begin goto ASCII; null;<<ASCII>> null; end;
/
insert into t2 values ('ASCII','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ASCII';
commit;
drop procedure f1;

create procedure f1 as begin goto ASENSITIVE; null;<<ASENSITIVE>> null; end;
/
insert into t2 values ('ASENSITIVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ASENSITIVE';
commit;
drop procedure f1;

create procedure f1 as begin goto AT; null;<<AT>> null; end;
/
insert into t2 values ('AT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AT';
commit;
drop procedure f1;

create procedure f1 as begin goto ATOMIC; null;<<ATOMIC>> null; end;
/
insert into t2 values ('ATOMIC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ATOMIC';
commit;
drop procedure f1;

create procedure f1 as begin goto AUTHORS; null;<<AUTHORS>> null; end;
/
insert into t2 values ('AUTHORS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AUTHORS';
commit;
drop procedure f1;

create procedure f1 as begin goto AUTO_INCREMENT; null;<<AUTO_INCREMENT>> null; end;
/
insert into t2 values ('AUTO_INCREMENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AUTO_INCREMENT';
commit;
drop procedure f1;

create procedure f1 as begin goto AUTOEXTEND_SIZE; null;<<AUTOEXTEND_SIZE>> null; end;
/
insert into t2 values ('AUTOEXTEND_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AUTOEXTEND_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto AUTO; null;<<AUTO>> null; end;
/
insert into t2 values ('AUTO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AUTO';
commit;
drop procedure f1;

create procedure f1 as begin goto AVG; null;<<AVG>> null; end;
/
insert into t2 values ('AVG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AVG';
commit;
drop procedure f1;

create procedure f1 as begin goto AVG_ROW_LENGTH; null;<<AVG_ROW_LENGTH>> null; end;
/
insert into t2 values ('AVG_ROW_LENGTH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='AVG_ROW_LENGTH';
commit;
drop procedure f1;

create procedure f1 as begin goto BACKUP; null;<<BACKUP>> null; end;
/
insert into t2 values ('BACKUP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BACKUP';
commit;
drop procedure f1;

create procedure f1 as begin goto BEFORE; null;<<BEFORE>> null; end;
/
insert into t2 values ('BEFORE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BEFORE';
commit;
drop procedure f1;

create procedure f1 as begin goto BEGIN; null;<<BEGIN>> null; end;
/
insert into t2 values ('BEGIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BEGIN';
commit;
drop procedure f1;

create procedure f1 as begin goto BETWEEN; null;<<BETWEEN>> null; end;
/
insert into t2 values ('BETWEEN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BETWEEN';
commit;
drop procedure f1;

create procedure f1 as begin goto BIGINT; null;<<BIGINT>> null; end;
/
insert into t2 values ('BIGINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BIGINT';
commit;
drop procedure f1;

create procedure f1 as begin goto BINARY; null;<<BINARY>> null; end;
/
insert into t2 values ('BINARY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BINARY';
commit;
drop procedure f1;

create procedure f1 as begin goto BINLOG; null;<<BINLOG>> null; end;
/
insert into t2 values ('BINLOG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BINLOG';
commit;
drop procedure f1;

create procedure f1 as begin goto BIT; null;<<BIT>> null; end;
/
insert into t2 values ('BIT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BIT';
commit;
drop procedure f1;

create procedure f1 as begin goto BLOB; null;<<BLOB>> null; end;
/
insert into t2 values ('BLOB','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BLOB';
commit;
drop procedure f1;

create procedure f1 as begin goto BLOCK; null;<<BLOCK>> null; end;
/
insert into t2 values ('BLOCK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BLOCK';
commit;
drop procedure f1;

create procedure f1 as begin goto BODY; null;<<BODY>> null; end;
/
insert into t2 values ('BODY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BODY';
commit;
drop procedure f1;

create procedure f1 as begin goto BOOL; null;<<BOOL>> null; end;
/
insert into t2 values ('BOOL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BOOL';
commit;
drop procedure f1;

create procedure f1 as begin goto BOOLEAN; null;<<BOOLEAN>> null; end;
/
insert into t2 values ('BOOLEAN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BOOLEAN';
commit;
drop procedure f1;

create procedure f1 as begin goto BOTH; null;<<BOTH>> null; end;
/
insert into t2 values ('BOTH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BOTH';
commit;
drop procedure f1;

create procedure f1 as begin goto BTREE; null;<<BTREE>> null; end;
/
insert into t2 values ('BTREE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BTREE';
commit;
drop procedure f1;

create procedure f1 as begin goto BY; null;<<BY>> null; end;
/
insert into t2 values ('BY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BY';
commit;
drop procedure f1;

create procedure f1 as begin goto BYTE; null;<<BYTE>> null; end;
/
insert into t2 values ('BYTE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BYTE';
commit;
drop procedure f1;

create procedure f1 as begin goto CACHE; null;<<CACHE>> null; end;
/
insert into t2 values ('CACHE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CACHE';
commit;
drop procedure f1;

create procedure f1 as begin goto CALL; null;<<CALL>> null; end;
/
insert into t2 values ('CALL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CALL';
commit;
drop procedure f1;

create procedure f1 as begin goto CASCADE; null;<<CASCADE>> null; end;
/
insert into t2 values ('CASCADE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CASCADE';
commit;
drop procedure f1;

create procedure f1 as begin goto CASCADED; null;<<CASCADED>> null; end;
/
insert into t2 values ('CASCADED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CASCADED';
commit;
drop procedure f1;

create procedure f1 as begin goto CASE; null;<<CASE>> null; end;
/
insert into t2 values ('CASE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CASE';
commit;
drop procedure f1;

create procedure f1 as begin goto CATALOG_NAME; null;<<CATALOG_NAME>> null; end;
/
insert into t2 values ('CATALOG_NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CATALOG_NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto CHAIN; null;<<CHAIN>> null; end;
/
insert into t2 values ('CHAIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHAIN';
commit;
drop procedure f1;

create procedure f1 as begin goto CHANGE; null;<<CHANGE>> null; end;
/
insert into t2 values ('CHANGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHANGE';
commit;
drop procedure f1;

create procedure f1 as begin goto CHANGED; null;<<CHANGED>> null; end;
/
insert into t2 values ('CHANGED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHANGED';
commit;
drop procedure f1;

create procedure f1 as begin goto CHAR; null;<<CHAR>> null; end;
/
insert into t2 values ('CHAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHAR';
commit;
drop procedure f1;

create procedure f1 as begin goto CHARACTER; null;<<CHARACTER>> null; end;
/
insert into t2 values ('CHARACTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHARACTER';
commit;
drop procedure f1;

create procedure f1 as begin goto CHARSET; null;<<CHARSET>> null; end;
/
insert into t2 values ('CHARSET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHARSET';
commit;
drop procedure f1;

create procedure f1 as begin goto CHECK; null;<<CHECK>> null; end;
/
insert into t2 values ('CHECK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHECK';
commit;
drop procedure f1;

create procedure f1 as begin goto CHECKPOINT; null;<<CHECKPOINT>> null; end;
/
insert into t2 values ('CHECKPOINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHECKPOINT';
commit;
drop procedure f1;

create procedure f1 as begin goto CHECKSUM; null;<<CHECKSUM>> null; end;
/
insert into t2 values ('CHECKSUM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CHECKSUM';
commit;
drop procedure f1;

create procedure f1 as begin goto CIPHER; null;<<CIPHER>> null; end;
/
insert into t2 values ('CIPHER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CIPHER';
commit;
drop procedure f1;

create procedure f1 as begin goto CLASS_ORIGIN; null;<<CLASS_ORIGIN>> null; end;
/
insert into t2 values ('CLASS_ORIGIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CLASS_ORIGIN';
commit;
drop procedure f1;

create procedure f1 as begin goto CLIENT; null;<<CLIENT>> null; end;
/
insert into t2 values ('CLIENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CLIENT';
commit;
drop procedure f1;

create procedure f1 as begin goto CLOB; null;<<CLOB>> null; end;
/
insert into t2 values ('CLOB','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CLOB';
commit;
drop procedure f1;

create procedure f1 as begin goto CLOSE; null;<<CLOSE>> null; end;
/
insert into t2 values ('CLOSE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CLOSE';
commit;
drop procedure f1;

create procedure f1 as begin goto COALESCE; null;<<COALESCE>> null; end;
/
insert into t2 values ('COALESCE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COALESCE';
commit;
drop procedure f1;

create procedure f1 as begin goto CODE; null;<<CODE>> null; end;
/
insert into t2 values ('CODE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CODE';
commit;
drop procedure f1;

create procedure f1 as begin goto COLLATE; null;<<COLLATE>> null; end;
/
insert into t2 values ('COLLATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLLATE';
commit;
drop procedure f1;

create procedure f1 as begin goto COLLATION; null;<<COLLATION>> null; end;
/
insert into t2 values ('COLLATION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLLATION';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN; null;<<COLUMN>> null; end;
/
insert into t2 values ('COLUMN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN_NAME; null;<<COLUMN_NAME>> null; end;
/
insert into t2 values ('COLUMN_NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN_NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMNS; null;<<COLUMNS>> null; end;
/
insert into t2 values ('COLUMNS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMNS';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN_ADD; null;<<COLUMN_ADD>> null; end;
/
insert into t2 values ('COLUMN_ADD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN_ADD';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN_CHECK; null;<<COLUMN_CHECK>> null; end;
/
insert into t2 values ('COLUMN_CHECK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN_CHECK';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN_CREATE; null;<<COLUMN_CREATE>> null; end;
/
insert into t2 values ('COLUMN_CREATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN_CREATE';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN_DELETE; null;<<COLUMN_DELETE>> null; end;
/
insert into t2 values ('COLUMN_DELETE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN_DELETE';
commit;
drop procedure f1;

create procedure f1 as begin goto COLUMN_GET; null;<<COLUMN_GET>> null; end;
/
insert into t2 values ('COLUMN_GET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COLUMN_GET';
commit;
drop procedure f1;

create procedure f1 as begin goto COMMENT; null;<<COMMENT>> null; end;
/
insert into t2 values ('COMMENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COMMENT';
commit;
drop procedure f1;

create procedure f1 as begin goto COMMIT; null;<<COMMIT>> null; end;
/
insert into t2 values ('COMMIT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COMMIT';
commit;
drop procedure f1;

create procedure f1 as begin goto COMMITTED; null;<<COMMITTED>> null; end;
/
insert into t2 values ('COMMITTED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COMMITTED';
commit;
drop procedure f1;

create procedure f1 as begin goto COMPACT; null;<<COMPACT>> null; end;
/
insert into t2 values ('COMPACT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COMPACT';
commit;
drop procedure f1;

create procedure f1 as begin goto COMPLETION; null;<<COMPLETION>> null; end;
/
insert into t2 values ('COMPLETION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COMPLETION';
commit;
drop procedure f1;

create procedure f1 as begin goto COMPRESSED; null;<<COMPRESSED>> null; end;
/
insert into t2 values ('COMPRESSED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COMPRESSED';
commit;
drop procedure f1;

create procedure f1 as begin goto CONCURRENT; null;<<CONCURRENT>> null; end;
/
insert into t2 values ('CONCURRENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONCURRENT';
commit;
drop procedure f1;

create procedure f1 as begin goto CONDITION; null;<<CONDITION>> null; end;
/
insert into t2 values ('CONDITION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONDITION';
commit;
drop procedure f1;

create procedure f1 as begin goto CONNECTION; null;<<CONNECTION>> null; end;
/
insert into t2 values ('CONNECTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONNECTION';
commit;
drop procedure f1;

create procedure f1 as begin goto CONSISTENT; null;<<CONSISTENT>> null; end;
/
insert into t2 values ('CONSISTENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONSISTENT';
commit;
drop procedure f1;

create procedure f1 as begin goto CONSTRAINT; null;<<CONSTRAINT>> null; end;
/
insert into t2 values ('CONSTRAINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONSTRAINT';
commit;
drop procedure f1;

create procedure f1 as begin goto CONSTRAINT_CATALOG; null;<<CONSTRAINT_CATALOG>> null; end;
/
insert into t2 values ('CONSTRAINT_CATALOG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONSTRAINT_CATALOG';
commit;
drop procedure f1;

create procedure f1 as begin goto CONSTRAINT_NAME; null;<<CONSTRAINT_NAME>> null; end;
/
insert into t2 values ('CONSTRAINT_NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONSTRAINT_NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto CONSTRAINT_SCHEMA; null;<<CONSTRAINT_SCHEMA>> null; end;
/
insert into t2 values ('CONSTRAINT_SCHEMA','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONSTRAINT_SCHEMA';
commit;
drop procedure f1;

create procedure f1 as begin goto CONTAINS; null;<<CONTAINS>> null; end;
/
insert into t2 values ('CONTAINS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONTAINS';
commit;
drop procedure f1;

create procedure f1 as begin goto CONTEXT; null;<<CONTEXT>> null; end;
/
insert into t2 values ('CONTEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONTEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto CONTINUE; null;<<CONTINUE>> null; end;
/
insert into t2 values ('CONTINUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONTINUE';
commit;
drop procedure f1;

create procedure f1 as begin goto CONTRIBUTORS; null;<<CONTRIBUTORS>> null; end;
/
insert into t2 values ('CONTRIBUTORS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONTRIBUTORS';
commit;
drop procedure f1;

create procedure f1 as begin goto CONVERT; null;<<CONVERT>> null; end;
/
insert into t2 values ('CONVERT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CONVERT';
commit;
drop procedure f1;

create procedure f1 as begin goto CPU; null;<<CPU>> null; end;
/
insert into t2 values ('CPU','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CPU';
commit;
drop procedure f1;

create procedure f1 as begin goto CREATE; null;<<CREATE>> null; end;
/
insert into t2 values ('CREATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CREATE';
commit;
drop procedure f1;

create procedure f1 as begin goto CROSS; null;<<CROSS>> null; end;
/
insert into t2 values ('CROSS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CROSS';
commit;
drop procedure f1;

create procedure f1 as begin goto CUBE; null;<<CUBE>> null; end;
/
insert into t2 values ('CUBE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CUBE';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT; null;<<CURRENT>> null; end;
/
insert into t2 values ('CURRENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT_DATE; null;<<CURRENT_DATE>> null; end;
/
insert into t2 values ('CURRENT_DATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT_DATE';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT_POS; null;<<CURRENT_POS>> null; end;
/
insert into t2 values ('CURRENT_POS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT_POS';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT_ROLE; null;<<CURRENT_ROLE>> null; end;
/
insert into t2 values ('CURRENT_ROLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT_ROLE';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT_TIME; null;<<CURRENT_TIME>> null; end;
/
insert into t2 values ('CURRENT_TIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT_TIME';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT_TIMESTAMP; null;<<CURRENT_TIMESTAMP>> null; end;
/
insert into t2 values ('CURRENT_TIMESTAMP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT_TIMESTAMP';
commit;
drop procedure f1;

create procedure f1 as begin goto CURRENT_USER; null;<<CURRENT_USER>> null; end;
/
insert into t2 values ('CURRENT_USER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURRENT_USER';
commit;
drop procedure f1;

create procedure f1 as begin goto CURSOR; null;<<CURSOR>> null; end;
/
insert into t2 values ('CURSOR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURSOR';
commit;
drop procedure f1;

create procedure f1 as begin goto CURSOR_NAME; null;<<CURSOR_NAME>> null; end;
/
insert into t2 values ('CURSOR_NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURSOR_NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto DATA; null;<<DATA>> null; end;
/
insert into t2 values ('DATA','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATA';
commit;
drop procedure f1;

create procedure f1 as begin goto DATABASE; null;<<DATABASE>> null; end;
/
insert into t2 values ('DATABASE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATABASE';
commit;
drop procedure f1;

create procedure f1 as begin goto DATABASES; null;<<DATABASES>> null; end;
/
insert into t2 values ('DATABASES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATABASES';
commit;
drop procedure f1;

create procedure f1 as begin goto DATAFILE; null;<<DATAFILE>> null; end;
/
insert into t2 values ('DATAFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATAFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto DATE; null;<<DATE>> null; end;
/
insert into t2 values ('DATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATE';
commit;
drop procedure f1;

create procedure f1 as begin goto DATETIME; null;<<DATETIME>> null; end;
/
insert into t2 values ('DATETIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATETIME';
commit;
drop procedure f1;

create procedure f1 as begin goto DAY; null;<<DAY>> null; end;
/
insert into t2 values ('DAY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DAY';
commit;
drop procedure f1;

create procedure f1 as begin goto DAY_HOUR; null;<<DAY_HOUR>> null; end;
/
insert into t2 values ('DAY_HOUR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DAY_HOUR';
commit;
drop procedure f1;

create procedure f1 as begin goto DAY_MICROSECOND; null;<<DAY_MICROSECOND>> null; end;
/
insert into t2 values ('DAY_MICROSECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DAY_MICROSECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto DAY_MINUTE; null;<<DAY_MINUTE>> null; end;
/
insert into t2 values ('DAY_MINUTE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DAY_MINUTE';
commit;
drop procedure f1;

create procedure f1 as begin goto DAY_SECOND; null;<<DAY_SECOND>> null; end;
/
insert into t2 values ('DAY_SECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DAY_SECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto DEALLOCATE; null;<<DEALLOCATE>> null; end;
/
insert into t2 values ('DEALLOCATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DEALLOCATE';
commit;
drop procedure f1;

create procedure f1 as begin goto DEC; null;<<DEC>> null; end;
/
insert into t2 values ('DEC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DEC';
commit;
drop procedure f1;

create procedure f1 as begin goto DECIMAL; null;<<DECIMAL>> null; end;
/
insert into t2 values ('DECIMAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DECIMAL';
commit;
drop procedure f1;

create procedure f1 as begin goto DECLARE; null;<<DECLARE>> null; end;
/
insert into t2 values ('DECLARE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DECLARE';
commit;
drop procedure f1;

create procedure f1 as begin goto DEFAULT; null;<<DEFAULT>> null; end;
/
insert into t2 values ('DEFAULT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DEFAULT';
commit;
drop procedure f1;

create procedure f1 as begin goto DEFINER; null;<<DEFINER>> null; end;
/
insert into t2 values ('DEFINER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DEFINER';
commit;
drop procedure f1;

create procedure f1 as begin goto DELAYED; null;<<DELAYED>> null; end;
/
insert into t2 values ('DELAYED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DELAYED';
commit;
drop procedure f1;

create procedure f1 as begin goto DELAY_KEY_WRITE; null;<<DELAY_KEY_WRITE>> null; end;
/
insert into t2 values ('DELAY_KEY_WRITE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DELAY_KEY_WRITE';
commit;
drop procedure f1;

create procedure f1 as begin goto DELETE; null;<<DELETE>> null; end;
/
insert into t2 values ('DELETE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DELETE';
commit;
drop procedure f1;

create procedure f1 as begin goto DESC; null;<<DESC>> null; end;
/
insert into t2 values ('DESC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DESC';
commit;
drop procedure f1;

create procedure f1 as begin goto DESCRIBE; null;<<DESCRIBE>> null; end;
/
insert into t2 values ('DESCRIBE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DESCRIBE';
commit;
drop procedure f1;

create procedure f1 as begin goto DES_KEY_FILE; null;<<DES_KEY_FILE>> null; end;
/
insert into t2 values ('DES_KEY_FILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DES_KEY_FILE';
commit;
drop procedure f1;

create procedure f1 as begin goto DETERMINISTIC; null;<<DETERMINISTIC>> null; end;
/
insert into t2 values ('DETERMINISTIC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DETERMINISTIC';
commit;
drop procedure f1;

create procedure f1 as begin goto DIAGNOSTICS; null;<<DIAGNOSTICS>> null; end;
/
insert into t2 values ('DIAGNOSTICS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DIAGNOSTICS';
commit;
drop procedure f1;

create procedure f1 as begin goto DIRECTORY; null;<<DIRECTORY>> null; end;
/
insert into t2 values ('DIRECTORY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DIRECTORY';
commit;
drop procedure f1;

create procedure f1 as begin goto DISABLE; null;<<DISABLE>> null; end;
/
insert into t2 values ('DISABLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DISABLE';
commit;
drop procedure f1;

create procedure f1 as begin goto DISCARD; null;<<DISCARD>> null; end;
/
insert into t2 values ('DISCARD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DISCARD';
commit;
drop procedure f1;

create procedure f1 as begin goto DISK; null;<<DISK>> null; end;
/
insert into t2 values ('DISK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DISK';
commit;
drop procedure f1;

create procedure f1 as begin goto DISTINCT; null;<<DISTINCT>> null; end;
/
insert into t2 values ('DISTINCT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DISTINCT';
commit;
drop procedure f1;

create procedure f1 as begin goto DISTINCTROW; null;<<DISTINCTROW>> null; end;
/
insert into t2 values ('DISTINCTROW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DISTINCTROW';
commit;
drop procedure f1;

create procedure f1 as begin goto DIV; null;<<DIV>> null; end;
/
insert into t2 values ('DIV','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DIV';
commit;
drop procedure f1;

create procedure f1 as begin goto DO; null;<<DO>> null; end;
/
insert into t2 values ('DO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DO';
commit;
drop procedure f1;

create procedure f1 as begin goto DOUBLE; null;<<DOUBLE>> null; end;
/
insert into t2 values ('DOUBLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DOUBLE';
commit;
drop procedure f1;

create procedure f1 as begin goto DO_DOMAIN_IDS; null;<<DO_DOMAIN_IDS>> null; end;
/
insert into t2 values ('DO_DOMAIN_IDS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DO_DOMAIN_IDS';
commit;
drop procedure f1;

create procedure f1 as begin goto DROP; null;<<DROP>> null; end;
/
insert into t2 values ('DROP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DROP';
commit;
drop procedure f1;

create procedure f1 as begin goto DUAL; null;<<DUAL>> null; end;
/
insert into t2 values ('DUAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DUAL';
commit;
drop procedure f1;

create procedure f1 as begin goto DUMPFILE; null;<<DUMPFILE>> null; end;
/
insert into t2 values ('DUMPFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DUMPFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto DUPLICATE; null;<<DUPLICATE>> null; end;
/
insert into t2 values ('DUPLICATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DUPLICATE';
commit;
drop procedure f1;

create procedure f1 as begin goto DYNAMIC; null;<<DYNAMIC>> null; end;
/
insert into t2 values ('DYNAMIC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DYNAMIC';
commit;
drop procedure f1;

create procedure f1 as begin goto EACH; null;<<EACH>> null; end;
/
insert into t2 values ('EACH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EACH';
commit;
drop procedure f1;

create procedure f1 as begin goto ELSE; null;<<ELSE>> null; end;
/
insert into t2 values ('ELSE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ELSE';
commit;
drop procedure f1;

create procedure f1 as begin goto ELSEIF; null;<<ELSEIF>> null; end;
/
insert into t2 values ('ELSEIF','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ELSEIF';
commit;
drop procedure f1;

create procedure f1 as begin goto ELSIF; null;<<ELSIF>> null; end;
/
insert into t2 values ('ELSIF','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ELSIF';
commit;
drop procedure f1;

create procedure f1 as begin goto ENABLE; null;<<ENABLE>> null; end;
/
insert into t2 values ('ENABLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ENABLE';
commit;
drop procedure f1;

create procedure f1 as begin goto ENCLOSED; null;<<ENCLOSED>> null; end;
/
insert into t2 values ('ENCLOSED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ENCLOSED';
commit;
drop procedure f1;

create procedure f1 as begin goto END; null;<<END>> null; end;
/
insert into t2 values ('END','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='END';
commit;
drop procedure f1;

create procedure f1 as begin goto ENDS; null;<<ENDS>> null; end;
/
insert into t2 values ('ENDS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ENDS';
commit;
drop procedure f1;

create procedure f1 as begin goto ENGINE; null;<<ENGINE>> null; end;
/
insert into t2 values ('ENGINE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ENGINE';
commit;
drop procedure f1;

create procedure f1 as begin goto ENGINES; null;<<ENGINES>> null; end;
/
insert into t2 values ('ENGINES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ENGINES';
commit;
drop procedure f1;

create procedure f1 as begin goto ENUM; null;<<ENUM>> null; end;
/
insert into t2 values ('ENUM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ENUM';
commit;
drop procedure f1;

create procedure f1 as begin goto ERROR; null;<<ERROR>> null; end;
/
insert into t2 values ('ERROR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ERROR';
commit;
drop procedure f1;

create procedure f1 as begin goto ERRORS; null;<<ERRORS>> null; end;
/
insert into t2 values ('ERRORS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ERRORS';
commit;
drop procedure f1;

create procedure f1 as begin goto ESCAPE; null;<<ESCAPE>> null; end;
/
insert into t2 values ('ESCAPE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ESCAPE';
commit;
drop procedure f1;

create procedure f1 as begin goto ESCAPED; null;<<ESCAPED>> null; end;
/
insert into t2 values ('ESCAPED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ESCAPED';
commit;
drop procedure f1;

create procedure f1 as begin goto EVENT; null;<<EVENT>> null; end;
/
insert into t2 values ('EVENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EVENT';
commit;
drop procedure f1;

create procedure f1 as begin goto EVENTS; null;<<EVENTS>> null; end;
/
insert into t2 values ('EVENTS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EVENTS';
commit;
drop procedure f1;

create procedure f1 as begin goto EVERY; null;<<EVERY>> null; end;
/
insert into t2 values ('EVERY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EVERY';
commit;
drop procedure f1;

create procedure f1 as begin goto EXAMINED; null;<<EXAMINED>> null; end;
/
insert into t2 values ('EXAMINED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXAMINED';
commit;
drop procedure f1;

create procedure f1 as begin goto EXCHANGE; null;<<EXCHANGE>> null; end;
/
insert into t2 values ('EXCHANGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXCHANGE';
commit;
drop procedure f1;

create procedure f1 as begin goto EXCLUDE; null;<<EXCLUDE>> null; end;
/
insert into t2 values ('EXCLUDE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXCLUDE';
commit;
drop procedure f1;

create procedure f1 as begin goto EXECUTE; null;<<EXECUTE>> null; end;
/
insert into t2 values ('EXECUTE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXECUTE';
commit;
drop procedure f1;

create procedure f1 as begin goto EXCEPTION; null;<<EXCEPTION>> null; end;
/
insert into t2 values ('EXCEPTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXCEPTION';
commit;
drop procedure f1;

create procedure f1 as begin goto EXISTS; null;<<EXISTS>> null; end;
/
insert into t2 values ('EXISTS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXISTS';
commit;
drop procedure f1;

create procedure f1 as begin goto EXIT; null;<<EXIT>> null; end;
/
insert into t2 values ('EXIT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXIT';
commit;
drop procedure f1;

create procedure f1 as begin goto EXPANSION; null;<<EXPANSION>> null; end;
/
insert into t2 values ('EXPANSION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXPANSION';
commit;
drop procedure f1;

create procedure f1 as begin goto EXPORT; null;<<EXPORT>> null; end;
/
insert into t2 values ('EXPORT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXPORT';
commit;
drop procedure f1;

create procedure f1 as begin goto EXPLAIN; null;<<EXPLAIN>> null; end;
/
insert into t2 values ('EXPLAIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXPLAIN';
commit;
drop procedure f1;

create procedure f1 as begin goto EXTENDED; null;<<EXTENDED>> null; end;
/
insert into t2 values ('EXTENDED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXTENDED';
commit;
drop procedure f1;

create procedure f1 as begin goto EXTENT_SIZE; null;<<EXTENT_SIZE>> null; end;
/
insert into t2 values ('EXTENT_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXTENT_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto FALSE; null;<<FALSE>> null; end;
/
insert into t2 values ('FALSE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FALSE';
commit;
drop procedure f1;

create procedure f1 as begin goto FAST; null;<<FAST>> null; end;
/
insert into t2 values ('FAST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FAST';
commit;
drop procedure f1;

create procedure f1 as begin goto FAULTS; null;<<FAULTS>> null; end;
/
insert into t2 values ('FAULTS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FAULTS';
commit;
drop procedure f1;

create procedure f1 as begin goto FETCH; null;<<FETCH>> null; end;
/
insert into t2 values ('FETCH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FETCH';
commit;
drop procedure f1;

create procedure f1 as begin goto FIELDS; null;<<FIELDS>> null; end;
/
insert into t2 values ('FIELDS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FIELDS';
commit;
drop procedure f1;

create procedure f1 as begin goto FILE; null;<<FILE>> null; end;
/
insert into t2 values ('FILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FILE';
commit;
drop procedure f1;

create procedure f1 as begin goto FIRST; null;<<FIRST>> null; end;
/
insert into t2 values ('FIRST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FIRST';
commit;
drop procedure f1;

create procedure f1 as begin goto FIXED; null;<<FIXED>> null; end;
/
insert into t2 values ('FIXED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FIXED';
commit;
drop procedure f1;

create procedure f1 as begin goto FLOAT; null;<<FLOAT>> null; end;
/
insert into t2 values ('FLOAT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FLOAT';
commit;
drop procedure f1;

create procedure f1 as begin goto FLOAT4; null;<<FLOAT4>> null; end;
/
insert into t2 values ('FLOAT4','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FLOAT4';
commit;
drop procedure f1;

create procedure f1 as begin goto FLOAT8; null;<<FLOAT8>> null; end;
/
insert into t2 values ('FLOAT8','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FLOAT8';
commit;
drop procedure f1;

create procedure f1 as begin goto FLUSH; null;<<FLUSH>> null; end;
/
insert into t2 values ('FLUSH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FLUSH';
commit;
drop procedure f1;

create procedure f1 as begin goto FOLLOWING; null;<<FOLLOWING>> null; end;
/
insert into t2 values ('FOLLOWING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FOLLOWING';
commit;
drop procedure f1;

create procedure f1 as begin goto FOLLOWS; null;<<FOLLOWS>> null; end;
/
insert into t2 values ('FOLLOWS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FOLLOWS';
commit;
drop procedure f1;

create procedure f1 as begin goto FOR; null;<<FOR>> null; end;
/
insert into t2 values ('FOR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FOR';
commit;
drop procedure f1;

create procedure f1 as begin goto FORCE; null;<<FORCE>> null; end;
/
insert into t2 values ('FORCE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FORCE';
commit;
drop procedure f1;

create procedure f1 as begin goto FOREIGN; null;<<FOREIGN>> null; end;
/
insert into t2 values ('FOREIGN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FOREIGN';
commit;
drop procedure f1;

create procedure f1 as begin goto FORMAT; null;<<FORMAT>> null; end;
/
insert into t2 values ('FORMAT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FORMAT';
commit;
drop procedure f1;

create procedure f1 as begin goto FOUND; null;<<FOUND>> null; end;
/
insert into t2 values ('FOUND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FOUND';
commit;
drop procedure f1;

create procedure f1 as begin goto FROM; null;<<FROM>> null; end;
/
insert into t2 values ('FROM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FROM';
commit;
drop procedure f1;

create procedure f1 as begin goto FULL; null;<<FULL>> null; end;
/
insert into t2 values ('FULL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FULL';
commit;
drop procedure f1;

create procedure f1 as begin goto FULLTEXT; null;<<FULLTEXT>> null; end;
/
insert into t2 values ('FULLTEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FULLTEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto FUNCTION; null;<<FUNCTION>> null; end;
/
insert into t2 values ('FUNCTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FUNCTION';
commit;
drop procedure f1;

create procedure f1 as begin goto GENERAL; null;<<GENERAL>> null; end;
/
insert into t2 values ('GENERAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GENERAL';
commit;
drop procedure f1;

create procedure f1 as begin goto GENERATED; null;<<GENERATED>> null; end;
/
insert into t2 values ('GENERATED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GENERATED';
commit;
drop procedure f1;

create procedure f1 as begin goto GEOMETRY; null;<<GEOMETRY>> null; end;
/
insert into t2 values ('GEOMETRY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GEOMETRY';
commit;
drop procedure f1;

create procedure f1 as begin goto GEOMETRYCOLLECTION; null;<<GEOMETRYCOLLECTION>> null; end;
/
insert into t2 values ('GEOMETRYCOLLECTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GEOMETRYCOLLECTION';
commit;
drop procedure f1;

create procedure f1 as begin goto GET_FORMAT; null;<<GET_FORMAT>> null; end;
/
insert into t2 values ('GET_FORMAT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GET_FORMAT';
commit;
drop procedure f1;

create procedure f1 as begin goto GET; null;<<GET>> null; end;
/
insert into t2 values ('GET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GET';
commit;
drop procedure f1;

create procedure f1 as begin goto GLOBAL; null;<<GLOBAL>> null; end;
/
insert into t2 values ('GLOBAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GLOBAL';
commit;
drop procedure f1;

create procedure f1 as begin goto GOTO; null;<<GOTO>> null; end;
/
insert into t2 values ('GOTO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GOTO';
commit;
drop procedure f1;

create procedure f1 as begin goto GRANT; null;<<GRANT>> null; end;
/
insert into t2 values ('GRANT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GRANT';
commit;
drop procedure f1;

create procedure f1 as begin goto GRANTS; null;<<GRANTS>> null; end;
/
insert into t2 values ('GRANTS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GRANTS';
commit;
drop procedure f1;

create procedure f1 as begin goto GROUP; null;<<GROUP>> null; end;
/
insert into t2 values ('GROUP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GROUP';
commit;
drop procedure f1;

create procedure f1 as begin goto HANDLER; null;<<HANDLER>> null; end;
/
insert into t2 values ('HANDLER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HANDLER';
commit;
drop procedure f1;

create procedure f1 as begin goto HARD; null;<<HARD>> null; end;
/
insert into t2 values ('HARD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HARD';
commit;
drop procedure f1;

create procedure f1 as begin goto HASH; null;<<HASH>> null; end;
/
insert into t2 values ('HASH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HASH';
commit;
drop procedure f1;

create procedure f1 as begin goto HAVING; null;<<HAVING>> null; end;
/
insert into t2 values ('HAVING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HAVING';
commit;
drop procedure f1;

create procedure f1 as begin goto HELP; null;<<HELP>> null; end;
/
insert into t2 values ('HELP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HELP';
commit;
drop procedure f1;

create procedure f1 as begin goto HIGH_PRIORITY; null;<<HIGH_PRIORITY>> null; end;
/
insert into t2 values ('HIGH_PRIORITY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HIGH_PRIORITY';
commit;
drop procedure f1;

create procedure f1 as begin goto HOST; null;<<HOST>> null; end;
/
insert into t2 values ('HOST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HOST';
commit;
drop procedure f1;

create procedure f1 as begin goto HOSTS; null;<<HOSTS>> null; end;
/
insert into t2 values ('HOSTS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HOSTS';
commit;
drop procedure f1;

create procedure f1 as begin goto HOUR; null;<<HOUR>> null; end;
/
insert into t2 values ('HOUR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HOUR';
commit;
drop procedure f1;

create procedure f1 as begin goto HOUR_MICROSECOND; null;<<HOUR_MICROSECOND>> null; end;
/
insert into t2 values ('HOUR_MICROSECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HOUR_MICROSECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto HOUR_MINUTE; null;<<HOUR_MINUTE>> null; end;
/
insert into t2 values ('HOUR_MINUTE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HOUR_MINUTE';
commit;
drop procedure f1;

create procedure f1 as begin goto HOUR_SECOND; null;<<HOUR_SECOND>> null; end;
/
insert into t2 values ('HOUR_SECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='HOUR_SECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto ID; null;<<ID>> null; end;
/
insert into t2 values ('ID','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ID';
commit;
drop procedure f1;

create procedure f1 as begin goto IDENTIFIED; null;<<IDENTIFIED>> null; end;
/
insert into t2 values ('IDENTIFIED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IDENTIFIED';
commit;
drop procedure f1;

create procedure f1 as begin goto IF; null;<<IF>> null; end;
/
insert into t2 values ('IF','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IF';
commit;
drop procedure f1;

create procedure f1 as begin goto IGNORE; null;<<IGNORE>> null; end;
/
insert into t2 values ('IGNORE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IGNORE';
commit;
drop procedure f1;

create procedure f1 as begin goto IGNORE_DOMAIN_IDS; null;<<IGNORE_DOMAIN_IDS>> null; end;
/
insert into t2 values ('IGNORE_DOMAIN_IDS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IGNORE_DOMAIN_IDS';
commit;
drop procedure f1;

create procedure f1 as begin goto IGNORE_SERVER_IDS; null;<<IGNORE_SERVER_IDS>> null; end;
/
insert into t2 values ('IGNORE_SERVER_IDS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IGNORE_SERVER_IDS';
commit;
drop procedure f1;

create procedure f1 as begin goto IMMEDIATE; null;<<IMMEDIATE>> null; end;
/
insert into t2 values ('IMMEDIATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IMMEDIATE';
commit;
drop procedure f1;

create procedure f1 as begin goto IMPORT; null;<<IMPORT>> null; end;
/
insert into t2 values ('IMPORT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IMPORT';
commit;
drop procedure f1;

create procedure f1 as begin goto IN; null;<<IN>> null; end;
/
insert into t2 values ('IN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IN';
commit;
drop procedure f1;

create procedure f1 as begin goto INDEX; null;<<INDEX>> null; end;
/
insert into t2 values ('INDEX','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INDEX';
commit;
drop procedure f1;

create procedure f1 as begin goto INDEXES; null;<<INDEXES>> null; end;
/
insert into t2 values ('INDEXES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INDEXES';
commit;
drop procedure f1;

create procedure f1 as begin goto INFILE; null;<<INFILE>> null; end;
/
insert into t2 values ('INFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto INITIAL_SIZE; null;<<INITIAL_SIZE>> null; end;
/
insert into t2 values ('INITIAL_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INITIAL_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto INNER; null;<<INNER>> null; end;
/
insert into t2 values ('INNER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INNER';
commit;
drop procedure f1;

create procedure f1 as begin goto INOUT; null;<<INOUT>> null; end;
/
insert into t2 values ('INOUT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INOUT';
commit;
drop procedure f1;

create procedure f1 as begin goto INSENSITIVE; null;<<INSENSITIVE>> null; end;
/
insert into t2 values ('INSENSITIVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INSENSITIVE';
commit;
drop procedure f1;

create procedure f1 as begin goto INSERT; null;<<INSERT>> null; end;
/
insert into t2 values ('INSERT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INSERT';
commit;
drop procedure f1;

create procedure f1 as begin goto INSERT_METHOD; null;<<INSERT_METHOD>> null; end;
/
insert into t2 values ('INSERT_METHOD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INSERT_METHOD';
commit;
drop procedure f1;

create procedure f1 as begin goto INSTALL; null;<<INSTALL>> null; end;
/
insert into t2 values ('INSTALL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INSTALL';
commit;
drop procedure f1;

create procedure f1 as begin goto INT; null;<<INT>> null; end;
/
insert into t2 values ('INT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INT';
commit;
drop procedure f1;

create procedure f1 as begin goto INT1; null;<<INT1>> null; end;
/
insert into t2 values ('INT1','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INT1';
commit;
drop procedure f1;

create procedure f1 as begin goto INT2; null;<<INT2>> null; end;
/
insert into t2 values ('INT2','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INT2';
commit;
drop procedure f1;

create procedure f1 as begin goto INT3; null;<<INT3>> null; end;
/
insert into t2 values ('INT3','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INT3';
commit;
drop procedure f1;

create procedure f1 as begin goto INT4; null;<<INT4>> null; end;
/
insert into t2 values ('INT4','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INT4';
commit;
drop procedure f1;

create procedure f1 as begin goto INT8; null;<<INT8>> null; end;
/
insert into t2 values ('INT8','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INT8';
commit;
drop procedure f1;

create procedure f1 as begin goto INTEGER; null;<<INTEGER>> null; end;
/
insert into t2 values ('INTEGER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INTEGER';
commit;
drop procedure f1;

create procedure f1 as begin goto INTERVAL; null;<<INTERVAL>> null; end;
/
insert into t2 values ('INTERVAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INTERVAL';
commit;
drop procedure f1;

create procedure f1 as begin goto INTO; null;<<INTO>> null; end;
/
insert into t2 values ('INTO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INTO';
commit;
drop procedure f1;

create procedure f1 as begin goto IO; null;<<IO>> null; end;
/
insert into t2 values ('IO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IO';
commit;
drop procedure f1;

create procedure f1 as begin goto IO_THREAD; null;<<IO_THREAD>> null; end;
/
insert into t2 values ('IO_THREAD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IO_THREAD';
commit;
drop procedure f1;

create procedure f1 as begin goto IPC; null;<<IPC>> null; end;
/
insert into t2 values ('IPC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IPC';
commit;
drop procedure f1;

create procedure f1 as begin goto IS; null;<<IS>> null; end;
/
insert into t2 values ('IS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='IS';
commit;
drop procedure f1;

create procedure f1 as begin goto ISOLATION; null;<<ISOLATION>> null; end;
/
insert into t2 values ('ISOLATION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ISOLATION';
commit;
drop procedure f1;

create procedure f1 as begin goto ISOPEN; null;<<ISOPEN>> null; end;
/
insert into t2 values ('ISOPEN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ISOPEN';
commit;
drop procedure f1;

create procedure f1 as begin goto ISSUER; null;<<ISSUER>> null; end;
/
insert into t2 values ('ISSUER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ISSUER';
commit;
drop procedure f1;

create procedure f1 as begin goto ITERATE; null;<<ITERATE>> null; end;
/
insert into t2 values ('ITERATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ITERATE';
commit;
drop procedure f1;

create procedure f1 as begin goto INVOKER; null;<<INVOKER>> null; end;
/
insert into t2 values ('INVOKER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='INVOKER';
commit;
drop procedure f1;

create procedure f1 as begin goto JOIN; null;<<JOIN>> null; end;
/
insert into t2 values ('JOIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='JOIN';
commit;
drop procedure f1;

create procedure f1 as begin goto JSON; null;<<JSON>> null; end;
/
insert into t2 values ('JSON','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='JSON';
commit;
drop procedure f1;

create procedure f1 as begin goto KEY; null;<<KEY>> null; end;
/
insert into t2 values ('KEY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='KEY';
commit;
drop procedure f1;

create procedure f1 as begin goto KEYS; null;<<KEYS>> null; end;
/
insert into t2 values ('KEYS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='KEYS';
commit;
drop procedure f1;

create procedure f1 as begin goto KEY_BLOCK_SIZE; null;<<KEY_BLOCK_SIZE>> null; end;
/
insert into t2 values ('KEY_BLOCK_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='KEY_BLOCK_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto KILL; null;<<KILL>> null; end;
/
insert into t2 values ('KILL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='KILL';
commit;
drop procedure f1;

create procedure f1 as begin goto LANGUAGE; null;<<LANGUAGE>> null; end;
/
insert into t2 values ('LANGUAGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LANGUAGE';
commit;
drop procedure f1;

create procedure f1 as begin goto LAST; null;<<LAST>> null; end;
/
insert into t2 values ('LAST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LAST';
commit;
drop procedure f1;

create procedure f1 as begin goto LAST_VALUE; null;<<LAST_VALUE>> null; end;
/
insert into t2 values ('LAST_VALUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LAST_VALUE';
commit;
drop procedure f1;

create procedure f1 as begin goto LEADING; null;<<LEADING>> null; end;
/
insert into t2 values ('LEADING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LEADING';
commit;
drop procedure f1;

create procedure f1 as begin goto LEAVE; null;<<LEAVE>> null; end;
/
insert into t2 values ('LEAVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LEAVE';
commit;
drop procedure f1;

create procedure f1 as begin goto LEAVES; null;<<LEAVES>> null; end;
/
insert into t2 values ('LEAVES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LEAVES';
commit;
drop procedure f1;

create procedure f1 as begin goto LEFT; null;<<LEFT>> null; end;
/
insert into t2 values ('LEFT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LEFT';
commit;
drop procedure f1;

create procedure f1 as begin goto LESS; null;<<LESS>> null; end;
/
insert into t2 values ('LESS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LESS';
commit;
drop procedure f1;

create procedure f1 as begin goto LEVEL; null;<<LEVEL>> null; end;
/
insert into t2 values ('LEVEL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LEVEL';
commit;
drop procedure f1;

create procedure f1 as begin goto LIKE; null;<<LIKE>> null; end;
/
insert into t2 values ('LIKE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LIKE';
commit;
drop procedure f1;

create procedure f1 as begin goto LIMIT; null;<<LIMIT>> null; end;
/
insert into t2 values ('LIMIT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LIMIT';
commit;
drop procedure f1;

create procedure f1 as begin goto LINEAR; null;<<LINEAR>> null; end;
/
insert into t2 values ('LINEAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LINEAR';
commit;
drop procedure f1;

create procedure f1 as begin goto LINES; null;<<LINES>> null; end;
/
insert into t2 values ('LINES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LINES';
commit;
drop procedure f1;

create procedure f1 as begin goto LINESTRING; null;<<LINESTRING>> null; end;
/
insert into t2 values ('LINESTRING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LINESTRING';
commit;
drop procedure f1;

create procedure f1 as begin goto LIST; null;<<LIST>> null; end;
/
insert into t2 values ('LIST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LIST';
commit;
drop procedure f1;

create procedure f1 as begin goto LOAD; null;<<LOAD>> null; end;
/
insert into t2 values ('LOAD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOAD';
commit;
drop procedure f1;

create procedure f1 as begin goto LOCAL; null;<<LOCAL>> null; end;
/
insert into t2 values ('LOCAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOCAL';
commit;
drop procedure f1;

create procedure f1 as begin goto LOCALTIME; null;<<LOCALTIME>> null; end;
/
insert into t2 values ('LOCALTIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOCALTIME';
commit;
drop procedure f1;

create procedure f1 as begin goto LOCALTIMESTAMP; null;<<LOCALTIMESTAMP>> null; end;
/
insert into t2 values ('LOCALTIMESTAMP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOCALTIMESTAMP';
commit;
drop procedure f1;

create procedure f1 as begin goto LOCK; null;<<LOCK>> null; end;
/
insert into t2 values ('LOCK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOCK';
commit;
drop procedure f1;

create procedure f1 as begin goto LOCKS; null;<<LOCKS>> null; end;
/
insert into t2 values ('LOCKS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOCKS';
commit;
drop procedure f1;

create procedure f1 as begin goto LOGFILE; null;<<LOGFILE>> null; end;
/
insert into t2 values ('LOGFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOGFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto LOGS; null;<<LOGS>> null; end;
/
insert into t2 values ('LOGS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOGS';
commit;
drop procedure f1;

create procedure f1 as begin goto LONG; null;<<LONG>> null; end;
/
insert into t2 values ('LONG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LONG';
commit;
drop procedure f1;

create procedure f1 as begin goto LONGBLOB; null;<<LONGBLOB>> null; end;
/
insert into t2 values ('LONGBLOB','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LONGBLOB';
commit;
drop procedure f1;

create procedure f1 as begin goto LONGTEXT; null;<<LONGTEXT>> null; end;
/
insert into t2 values ('LONGTEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LONGTEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto LOOP; null;<<LOOP>> null; end;
/
insert into t2 values ('LOOP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOOP';
commit;
drop procedure f1;

create procedure f1 as begin goto LOW_PRIORITY; null;<<LOW_PRIORITY>> null; end;
/
insert into t2 values ('LOW_PRIORITY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LOW_PRIORITY';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER; null;<<MASTER>> null; end;
/
insert into t2 values ('MASTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_CONNECT_RETRY; null;<<MASTER_CONNECT_RETRY>> null; end;
/
insert into t2 values ('MASTER_CONNECT_RETRY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_CONNECT_RETRY';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_DELAY; null;<<MASTER_DELAY>> null; end;
/
insert into t2 values ('MASTER_DELAY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_DELAY';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_GTID_POS; null;<<MASTER_GTID_POS>> null; end;
/
insert into t2 values ('MASTER_GTID_POS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_GTID_POS';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_HOST; null;<<MASTER_HOST>> null; end;
/
insert into t2 values ('MASTER_HOST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_HOST';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_LOG_FILE; null;<<MASTER_LOG_FILE>> null; end;
/
insert into t2 values ('MASTER_LOG_FILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_LOG_FILE';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_LOG_POS; null;<<MASTER_LOG_POS>> null; end;
/
insert into t2 values ('MASTER_LOG_POS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_LOG_POS';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_PASSWORD; null;<<MASTER_PASSWORD>> null; end;
/
insert into t2 values ('MASTER_PASSWORD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_PASSWORD';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_PORT; null;<<MASTER_PORT>> null; end;
/
insert into t2 values ('MASTER_PORT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_PORT';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SERVER_ID; null;<<MASTER_SERVER_ID>> null; end;
/
insert into t2 values ('MASTER_SERVER_ID','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SERVER_ID';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL; null;<<MASTER_SSL>> null; end;
/
insert into t2 values ('MASTER_SSL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_CA; null;<<MASTER_SSL_CA>> null; end;
/
insert into t2 values ('MASTER_SSL_CA','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_CA';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_CAPATH; null;<<MASTER_SSL_CAPATH>> null; end;
/
insert into t2 values ('MASTER_SSL_CAPATH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_CAPATH';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_CERT; null;<<MASTER_SSL_CERT>> null; end;
/
insert into t2 values ('MASTER_SSL_CERT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_CERT';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_CIPHER; null;<<MASTER_SSL_CIPHER>> null; end;
/
insert into t2 values ('MASTER_SSL_CIPHER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_CIPHER';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_CRL; null;<<MASTER_SSL_CRL>> null; end;
/
insert into t2 values ('MASTER_SSL_CRL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_CRL';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_CRLPATH; null;<<MASTER_SSL_CRLPATH>> null; end;
/
insert into t2 values ('MASTER_SSL_CRLPATH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_CRLPATH';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_KEY; null;<<MASTER_SSL_KEY>> null; end;
/
insert into t2 values ('MASTER_SSL_KEY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_KEY';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_SSL_VERIFY_SERVER_CERT; null;<<MASTER_SSL_VERIFY_SERVER_CERT>> null; end;
/
insert into t2 values ('MASTER_SSL_VERIFY_SERVER_CERT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_SSL_VERIFY_SERVER_CERT';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_USER; null;<<MASTER_USER>> null; end;
/
insert into t2 values ('MASTER_USER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_USER';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_USE_GTID; null;<<MASTER_USE_GTID>> null; end;
/
insert into t2 values ('MASTER_USE_GTID','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_USE_GTID';
commit;
drop procedure f1;

create procedure f1 as begin goto MASTER_HEARTBEAT_PERIOD; null;<<MASTER_HEARTBEAT_PERIOD>> null; end;
/
insert into t2 values ('MASTER_HEARTBEAT_PERIOD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MASTER_HEARTBEAT_PERIOD';
commit;
drop procedure f1;

create procedure f1 as begin goto MATCH; null;<<MATCH>> null; end;
/
insert into t2 values ('MATCH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MATCH';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_CONNECTIONS_PER_HOUR; null;<<MAX_CONNECTIONS_PER_HOUR>> null; end;
/
insert into t2 values ('MAX_CONNECTIONS_PER_HOUR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_CONNECTIONS_PER_HOUR';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_QUERIES_PER_HOUR; null;<<MAX_QUERIES_PER_HOUR>> null; end;
/
insert into t2 values ('MAX_QUERIES_PER_HOUR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_QUERIES_PER_HOUR';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_ROWS; null;<<MAX_ROWS>> null; end;
/
insert into t2 values ('MAX_ROWS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_ROWS';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_SIZE; null;<<MAX_SIZE>> null; end;
/
insert into t2 values ('MAX_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_STATEMENT_TIME; null;<<MAX_STATEMENT_TIME>> null; end;
/
insert into t2 values ('MAX_STATEMENT_TIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_STATEMENT_TIME';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_UPDATES_PER_HOUR; null;<<MAX_UPDATES_PER_HOUR>> null; end;
/
insert into t2 values ('MAX_UPDATES_PER_HOUR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_UPDATES_PER_HOUR';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX_USER_CONNECTIONS; null;<<MAX_USER_CONNECTIONS>> null; end;
/
insert into t2 values ('MAX_USER_CONNECTIONS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX_USER_CONNECTIONS';
commit;
drop procedure f1;

create procedure f1 as begin goto MAXVALUE; null;<<MAXVALUE>> null; end;
/
insert into t2 values ('MAXVALUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAXVALUE';
commit;
drop procedure f1;

create procedure f1 as begin goto MEDIUM; null;<<MEDIUM>> null; end;
/
insert into t2 values ('MEDIUM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MEDIUM';
commit;
drop procedure f1;

create procedure f1 as begin goto MEDIUMBLOB; null;<<MEDIUMBLOB>> null; end;
/
insert into t2 values ('MEDIUMBLOB','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MEDIUMBLOB';
commit;
drop procedure f1;

create procedure f1 as begin goto MEDIUMINT; null;<<MEDIUMINT>> null; end;
/
insert into t2 values ('MEDIUMINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MEDIUMINT';
commit;
drop procedure f1;

create procedure f1 as begin goto MEDIUMTEXT; null;<<MEDIUMTEXT>> null; end;
/
insert into t2 values ('MEDIUMTEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MEDIUMTEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto MEMORY; null;<<MEMORY>> null; end;
/
insert into t2 values ('MEMORY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MEMORY';
commit;
drop procedure f1;

create procedure f1 as begin goto MERGE; null;<<MERGE>> null; end;
/
insert into t2 values ('MERGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MERGE';
commit;
drop procedure f1;

create procedure f1 as begin goto MESSAGE_TEXT; null;<<MESSAGE_TEXT>> null; end;
/
insert into t2 values ('MESSAGE_TEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MESSAGE_TEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto MICROSECOND; null;<<MICROSECOND>> null; end;
/
insert into t2 values ('MICROSECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MICROSECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto MIDDLEINT; null;<<MIDDLEINT>> null; end;
/
insert into t2 values ('MIDDLEINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MIDDLEINT';
commit;
drop procedure f1;

create procedure f1 as begin goto MIGRATE; null;<<MIGRATE>> null; end;
/
insert into t2 values ('MIGRATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MIGRATE';
commit;
drop procedure f1;

create procedure f1 as begin goto MINUTE; null;<<MINUTE>> null; end;
/
insert into t2 values ('MINUTE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MINUTE';
commit;
drop procedure f1;

create procedure f1 as begin goto MINUTE_MICROSECOND; null;<<MINUTE_MICROSECOND>> null; end;
/
insert into t2 values ('MINUTE_MICROSECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MINUTE_MICROSECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto MINUTE_SECOND; null;<<MINUTE_SECOND>> null; end;
/
insert into t2 values ('MINUTE_SECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MINUTE_SECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto MIN_ROWS; null;<<MIN_ROWS>> null; end;
/
insert into t2 values ('MIN_ROWS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MIN_ROWS';
commit;
drop procedure f1;

create procedure f1 as begin goto MOD; null;<<MOD>> null; end;
/
insert into t2 values ('MOD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MOD';
commit;
drop procedure f1;

create procedure f1 as begin goto MODE; null;<<MODE>> null; end;
/
insert into t2 values ('MODE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MODE';
commit;
drop procedure f1;

create procedure f1 as begin goto MODIFIES; null;<<MODIFIES>> null; end;
/
insert into t2 values ('MODIFIES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MODIFIES';
commit;
drop procedure f1;

create procedure f1 as begin goto MODIFY; null;<<MODIFY>> null; end;
/
insert into t2 values ('MODIFY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MODIFY';
commit;
drop procedure f1;

create procedure f1 as begin goto MONTH; null;<<MONTH>> null; end;
/
insert into t2 values ('MONTH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MONTH';
commit;
drop procedure f1;

create procedure f1 as begin goto MULTILINESTRING; null;<<MULTILINESTRING>> null; end;
/
insert into t2 values ('MULTILINESTRING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MULTILINESTRING';
commit;
drop procedure f1;

create procedure f1 as begin goto MULTIPOINT; null;<<MULTIPOINT>> null; end;
/
insert into t2 values ('MULTIPOINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MULTIPOINT';
commit;
drop procedure f1;

create procedure f1 as begin goto MULTIPOLYGON; null;<<MULTIPOLYGON>> null; end;
/
insert into t2 values ('MULTIPOLYGON','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MULTIPOLYGON';
commit;
drop procedure f1;

create procedure f1 as begin goto MUTEX; null;<<MUTEX>> null; end;
/
insert into t2 values ('MUTEX','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MUTEX';
commit;
drop procedure f1;

create procedure f1 as begin goto MYSQL; null;<<MYSQL>> null; end;
/
insert into t2 values ('MYSQL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MYSQL';
commit;
drop procedure f1;

create procedure f1 as begin goto MYSQL_ERRNO; null;<<MYSQL_ERRNO>> null; end;
/
insert into t2 values ('MYSQL_ERRNO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MYSQL_ERRNO';
commit;
drop procedure f1;

create procedure f1 as begin goto NAME; null;<<NAME>> null; end;
/
insert into t2 values ('NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto NAMES; null;<<NAMES>> null; end;
/
insert into t2 values ('NAMES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NAMES';
commit;
drop procedure f1;

create procedure f1 as begin goto NATIONAL; null;<<NATIONAL>> null; end;
/
insert into t2 values ('NATIONAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NATIONAL';
commit;
drop procedure f1;

create procedure f1 as begin goto NATURAL; null;<<NATURAL>> null; end;
/
insert into t2 values ('NATURAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NATURAL';
commit;
drop procedure f1;

create procedure f1 as begin goto NCHAR; null;<<NCHAR>> null; end;
/
insert into t2 values ('NCHAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NCHAR';
commit;
drop procedure f1;

create procedure f1 as begin goto NEW; null;<<NEW>> null; end;
/
insert into t2 values ('NEW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NEW';
commit;
drop procedure f1;

create procedure f1 as begin goto NEXT; null;<<NEXT>> null; end;
/
insert into t2 values ('NEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto NO; null;<<NO>> null; end;
/
insert into t2 values ('NO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NO';
commit;
drop procedure f1;

create procedure f1 as begin goto NO_WAIT; null;<<NO_WAIT>> null; end;
/
insert into t2 values ('NO_WAIT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NO_WAIT';
commit;
drop procedure f1;

create procedure f1 as begin goto NODEGROUP; null;<<NODEGROUP>> null; end;
/
insert into t2 values ('NODEGROUP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NODEGROUP';
commit;
drop procedure f1;

create procedure f1 as begin goto NONE; null;<<NONE>> null; end;
/
insert into t2 values ('NONE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NONE';
commit;
drop procedure f1;

create procedure f1 as begin goto NOT; null;<<NOT>> null; end;
/
insert into t2 values ('NOT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NOT';
commit;
drop procedure f1;

create procedure f1 as begin goto NOTFOUND; null;<<NOTFOUND>> null; end;
/
insert into t2 values ('NOTFOUND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NOTFOUND';
commit;
drop procedure f1;

create procedure f1 as begin goto NO_WRITE_TO_BINLOG; null;<<NO_WRITE_TO_BINLOG>> null; end;
/
insert into t2 values ('NO_WRITE_TO_BINLOG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NO_WRITE_TO_BINLOG';
commit;
drop procedure f1;

create procedure f1 as begin goto NULL; null;<<NULL>> null; end;
/
insert into t2 values ('NULL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NULL';
commit;
drop procedure f1;

create procedure f1 as begin goto NUMBER; null;<<NUMBER>> null; end;
/
insert into t2 values ('NUMBER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NUMBER';
commit;
drop procedure f1;

create procedure f1 as begin goto NUMERIC; null;<<NUMERIC>> null; end;
/
insert into t2 values ('NUMERIC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NUMERIC';
commit;
drop procedure f1;

create procedure f1 as begin goto NVARCHAR; null;<<NVARCHAR>> null; end;
/
insert into t2 values ('NVARCHAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NVARCHAR';
commit;
drop procedure f1;

create procedure f1 as begin goto OFFSET; null;<<OFFSET>> null; end;
/
insert into t2 values ('OFFSET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OFFSET';
commit;
drop procedure f1;

create procedure f1 as begin goto OLD_PASSWORD; null;<<OLD_PASSWORD>> null; end;
/
insert into t2 values ('OLD_PASSWORD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OLD_PASSWORD';
commit;
drop procedure f1;

create procedure f1 as begin goto ON; null;<<ON>> null; end;
/
insert into t2 values ('ON','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ON';
commit;
drop procedure f1;

create procedure f1 as begin goto ONE; null;<<ONE>> null; end;
/
insert into t2 values ('ONE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ONE';
commit;
drop procedure f1;

create procedure f1 as begin goto ONLINE; null;<<ONLINE>> null; end;
/
insert into t2 values ('ONLINE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ONLINE';
commit;
drop procedure f1;

create procedure f1 as begin goto ONLY; null;<<ONLY>> null; end;
/
insert into t2 values ('ONLY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ONLY';
commit;
drop procedure f1;

create procedure f1 as begin goto OPEN; null;<<OPEN>> null; end;
/
insert into t2 values ('OPEN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OPEN';
commit;
drop procedure f1;

create procedure f1 as begin goto OPTIMIZE; null;<<OPTIMIZE>> null; end;
/
insert into t2 values ('OPTIMIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OPTIMIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto OPTIONS; null;<<OPTIONS>> null; end;
/
insert into t2 values ('OPTIONS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OPTIONS';
commit;
drop procedure f1;

create procedure f1 as begin goto OPTION; null;<<OPTION>> null; end;
/
insert into t2 values ('OPTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OPTION';
commit;
drop procedure f1;

create procedure f1 as begin goto OPTIONALLY; null;<<OPTIONALLY>> null; end;
/
insert into t2 values ('OPTIONALLY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OPTIONALLY';
commit;
drop procedure f1;

create procedure f1 as begin goto OR; null;<<OR>> null; end;
/
insert into t2 values ('OR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OR';
commit;
drop procedure f1;

create procedure f1 as begin goto ORDER; null;<<ORDER>> null; end;
/
insert into t2 values ('ORDER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ORDER';
commit;
drop procedure f1;

create procedure f1 as begin goto OTHERS; null;<<OTHERS>> null; end;
/
insert into t2 values ('OTHERS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OTHERS';
commit;
drop procedure f1;

create procedure f1 as begin goto OUT; null;<<OUT>> null; end;
/
insert into t2 values ('OUT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OUT';
commit;
drop procedure f1;

create procedure f1 as begin goto OUTER; null;<<OUTER>> null; end;
/
insert into t2 values ('OUTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OUTER';
commit;
drop procedure f1;

create procedure f1 as begin goto OUTFILE; null;<<OUTFILE>> null; end;
/
insert into t2 values ('OUTFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OUTFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto OVER; null;<<OVER>> null; end;
/
insert into t2 values ('OVER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OVER';
commit;
drop procedure f1;

create procedure f1 as begin goto OWNER; null;<<OWNER>> null; end;
/
insert into t2 values ('OWNER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='OWNER';
commit;
drop procedure f1;

create procedure f1 as begin goto PACKAGE; null;<<PACKAGE>> null; end;
/
insert into t2 values ('PACKAGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PACKAGE';
commit;
drop procedure f1;

create procedure f1 as begin goto PACK_KEYS; null;<<PACK_KEYS>> null; end;
/
insert into t2 values ('PACK_KEYS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PACK_KEYS';
commit;
drop procedure f1;

create procedure f1 as begin goto PAGE; null;<<PAGE>> null; end;
/
insert into t2 values ('PAGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PAGE';
commit;
drop procedure f1;

create procedure f1 as begin goto PAGE_CHECKSUM; null;<<PAGE_CHECKSUM>> null; end;
/
insert into t2 values ('PAGE_CHECKSUM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PAGE_CHECKSUM';
commit;
drop procedure f1;

create procedure f1 as begin goto PARSER; null;<<PARSER>> null; end;
/
insert into t2 values ('PARSER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PARSER';
commit;
drop procedure f1;

create procedure f1 as begin goto PARSE_VCOL_EXPR; null;<<PARSE_VCOL_EXPR>> null; end;
/
insert into t2 values ('PARSE_VCOL_EXPR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PARSE_VCOL_EXPR';
commit;
drop procedure f1;

create procedure f1 as begin goto PARTIAL; null;<<PARTIAL>> null; end;
/
insert into t2 values ('PARTIAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PARTIAL';
commit;
drop procedure f1;

create procedure f1 as begin goto PARTITION; null;<<PARTITION>> null; end;
/
insert into t2 values ('PARTITION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PARTITION';
commit;
drop procedure f1;

create procedure f1 as begin goto PARTITIONING; null;<<PARTITIONING>> null; end;
/
insert into t2 values ('PARTITIONING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PARTITIONING';
commit;
drop procedure f1;

create procedure f1 as begin goto PARTITIONS; null;<<PARTITIONS>> null; end;
/
insert into t2 values ('PARTITIONS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PARTITIONS';
commit;
drop procedure f1;

create procedure f1 as begin goto PASSWORD; null;<<PASSWORD>> null; end;
/
insert into t2 values ('PASSWORD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PASSWORD';
commit;
drop procedure f1;

create procedure f1 as begin goto PERSISTENT; null;<<PERSISTENT>> null; end;
/
insert into t2 values ('PERSISTENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PERSISTENT';
commit;
drop procedure f1;

create procedure f1 as begin goto PHASE; null;<<PHASE>> null; end;
/
insert into t2 values ('PHASE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PHASE';
commit;
drop procedure f1;

create procedure f1 as begin goto PLUGIN; null;<<PLUGIN>> null; end;
/
insert into t2 values ('PLUGIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PLUGIN';
commit;
drop procedure f1;

create procedure f1 as begin goto PLUGINS; null;<<PLUGINS>> null; end;
/
insert into t2 values ('PLUGINS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PLUGINS';
commit;
drop procedure f1;

create procedure f1 as begin goto POINT; null;<<POINT>> null; end;
/
insert into t2 values ('POINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='POINT';
commit;
drop procedure f1;

create procedure f1 as begin goto POLYGON; null;<<POLYGON>> null; end;
/
insert into t2 values ('POLYGON','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='POLYGON';
commit;
drop procedure f1;

create procedure f1 as begin goto PORT; null;<<PORT>> null; end;
/
insert into t2 values ('PORT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PORT';
commit;
drop procedure f1;

create procedure f1 as begin goto PRECEDES; null;<<PRECEDES>> null; end;
/
insert into t2 values ('PRECEDES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PRECEDES';
commit;
drop procedure f1;

create procedure f1 as begin goto PRECEDING; null;<<PRECEDING>> null; end;
/
insert into t2 values ('PRECEDING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PRECEDING';
commit;
drop procedure f1;

create procedure f1 as begin goto PRECISION; null;<<PRECISION>> null; end;
/
insert into t2 values ('PRECISION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PRECISION';
commit;
drop procedure f1;

create procedure f1 as begin goto PREPARE; null;<<PREPARE>> null; end;
/
insert into t2 values ('PREPARE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PREPARE';
commit;
drop procedure f1;

create procedure f1 as begin goto PRESERVE; null;<<PRESERVE>> null; end;
/
insert into t2 values ('PRESERVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PRESERVE';
commit;
drop procedure f1;

create procedure f1 as begin goto PREV; null;<<PREV>> null; end;
/
insert into t2 values ('PREV','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PREV';
commit;
drop procedure f1;

create procedure f1 as begin goto PRIMARY; null;<<PRIMARY>> null; end;
/
insert into t2 values ('PRIMARY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PRIMARY';
commit;
drop procedure f1;

create procedure f1 as begin goto PRIVILEGES; null;<<PRIVILEGES>> null; end;
/
insert into t2 values ('PRIVILEGES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PRIVILEGES';
commit;
drop procedure f1;

create procedure f1 as begin goto PROCEDURE; null;<<PROCEDURE>> null; end;
/
insert into t2 values ('PROCEDURE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PROCEDURE';
commit;
drop procedure f1;

create procedure f1 as begin goto PROCESS; null;<<PROCESS>> null; end;
/
insert into t2 values ('PROCESS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PROCESS';
commit;
drop procedure f1;

create procedure f1 as begin goto PROCESSLIST; null;<<PROCESSLIST>> null; end;
/
insert into t2 values ('PROCESSLIST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PROCESSLIST';
commit;
drop procedure f1;

create procedure f1 as begin goto PROFILE; null;<<PROFILE>> null; end;
/
insert into t2 values ('PROFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PROFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto PROFILES; null;<<PROFILES>> null; end;
/
insert into t2 values ('PROFILES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PROFILES';
commit;
drop procedure f1;

create procedure f1 as begin goto PROXY; null;<<PROXY>> null; end;
/
insert into t2 values ('PROXY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PROXY';
commit;
drop procedure f1;

create procedure f1 as begin goto PURGE; null;<<PURGE>> null; end;
/
insert into t2 values ('PURGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PURGE';
commit;
drop procedure f1;

create procedure f1 as begin goto QUARTER; null;<<QUARTER>> null; end;
/
insert into t2 values ('QUARTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='QUARTER';
commit;
drop procedure f1;

create procedure f1 as begin goto QUERY; null;<<QUERY>> null; end;
/
insert into t2 values ('QUERY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='QUERY';
commit;
drop procedure f1;

create procedure f1 as begin goto QUICK; null;<<QUICK>> null; end;
/
insert into t2 values ('QUICK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='QUICK';
commit;
drop procedure f1;

create procedure f1 as begin goto RAISE; null;<<RAISE>> null; end;
/
insert into t2 values ('RAISE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RAISE';
commit;
drop procedure f1;

create procedure f1 as begin goto RANGE; null;<<RANGE>> null; end;
/
insert into t2 values ('RANGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RANGE';
commit;
drop procedure f1;

create procedure f1 as begin goto RAW; null;<<RAW>> null; end;
/
insert into t2 values ('RAW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RAW';
commit;
drop procedure f1;

create procedure f1 as begin goto READ; null;<<READ>> null; end;
/
insert into t2 values ('READ','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='READ';
commit;
drop procedure f1;

create procedure f1 as begin goto READ_ONLY; null;<<READ_ONLY>> null; end;
/
insert into t2 values ('READ_ONLY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='READ_ONLY';
commit;
drop procedure f1;

create procedure f1 as begin goto READ_WRITE; null;<<READ_WRITE>> null; end;
/
insert into t2 values ('READ_WRITE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='READ_WRITE';
commit;
drop procedure f1;

create procedure f1 as begin goto READS; null;<<READS>> null; end;
/
insert into t2 values ('READS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='READS';
commit;
drop procedure f1;

create procedure f1 as begin goto REAL; null;<<REAL>> null; end;
/
insert into t2 values ('REAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REAL';
commit;
drop procedure f1;

create procedure f1 as begin goto REBUILD; null;<<REBUILD>> null; end;
/
insert into t2 values ('REBUILD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REBUILD';
commit;
drop procedure f1;

create procedure f1 as begin goto RECOVER; null;<<RECOVER>> null; end;
/
insert into t2 values ('RECOVER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RECOVER';
commit;
drop procedure f1;

create procedure f1 as begin goto RECURSIVE; null;<<RECURSIVE>> null; end;
/
insert into t2 values ('RECURSIVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RECURSIVE';
commit;
drop procedure f1;

create procedure f1 as begin goto REDO_BUFFER_SIZE; null;<<REDO_BUFFER_SIZE>> null; end;
/
insert into t2 values ('REDO_BUFFER_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REDO_BUFFER_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto REDOFILE; null;<<REDOFILE>> null; end;
/
insert into t2 values ('REDOFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REDOFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto REDUNDANT; null;<<REDUNDANT>> null; end;
/
insert into t2 values ('REDUNDANT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REDUNDANT';
commit;
drop procedure f1;

create procedure f1 as begin goto REFERENCES; null;<<REFERENCES>> null; end;
/
insert into t2 values ('REFERENCES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REFERENCES';
commit;
drop procedure f1;

create procedure f1 as begin goto REGEXP; null;<<REGEXP>> null; end;
/
insert into t2 values ('REGEXP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REGEXP';
commit;
drop procedure f1;

create procedure f1 as begin goto RELAY; null;<<RELAY>> null; end;
/
insert into t2 values ('RELAY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELAY';
commit;
drop procedure f1;

create procedure f1 as begin goto RELAYLOG; null;<<RELAYLOG>> null; end;
/
insert into t2 values ('RELAYLOG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELAYLOG';
commit;
drop procedure f1;

create procedure f1 as begin goto RELAY_LOG_FILE; null;<<RELAY_LOG_FILE>> null; end;
/
insert into t2 values ('RELAY_LOG_FILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELAY_LOG_FILE';
commit;
drop procedure f1;

create procedure f1 as begin goto RELAY_LOG_POS; null;<<RELAY_LOG_POS>> null; end;
/
insert into t2 values ('RELAY_LOG_POS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELAY_LOG_POS';
commit;
drop procedure f1;

create procedure f1 as begin goto RELAY_THREAD; null;<<RELAY_THREAD>> null; end;
/
insert into t2 values ('RELAY_THREAD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELAY_THREAD';
commit;
drop procedure f1;

create procedure f1 as begin goto RELEASE; null;<<RELEASE>> null; end;
/
insert into t2 values ('RELEASE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELEASE';
commit;
drop procedure f1;

create procedure f1 as begin goto RELOAD; null;<<RELOAD>> null; end;
/
insert into t2 values ('RELOAD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RELOAD';
commit;
drop procedure f1;

create procedure f1 as begin goto REMOVE; null;<<REMOVE>> null; end;
/
insert into t2 values ('REMOVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REMOVE';
commit;
drop procedure f1;

create procedure f1 as begin goto RENAME; null;<<RENAME>> null; end;
/
insert into t2 values ('RENAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RENAME';
commit;
drop procedure f1;

create procedure f1 as begin goto REORGANIZE; null;<<REORGANIZE>> null; end;
/
insert into t2 values ('REORGANIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REORGANIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto REPAIR; null;<<REPAIR>> null; end;
/
insert into t2 values ('REPAIR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REPAIR';
commit;
drop procedure f1;

create procedure f1 as begin goto REPEATABLE; null;<<REPEATABLE>> null; end;
/
insert into t2 values ('REPEATABLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REPEATABLE';
commit;
drop procedure f1;

create procedure f1 as begin goto REPLACE; null;<<REPLACE>> null; end;
/
insert into t2 values ('REPLACE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REPLACE';
commit;
drop procedure f1;

create procedure f1 as begin goto REPLICATION; null;<<REPLICATION>> null; end;
/
insert into t2 values ('REPLICATION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REPLICATION';
commit;
drop procedure f1;

create procedure f1 as begin goto REPEAT; null;<<REPEAT>> null; end;
/
insert into t2 values ('REPEAT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REPEAT';
commit;
drop procedure f1;

create procedure f1 as begin goto REQUIRE; null;<<REQUIRE>> null; end;
/
insert into t2 values ('REQUIRE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REQUIRE';
commit;
drop procedure f1;

create procedure f1 as begin goto RESET; null;<<RESET>> null; end;
/
insert into t2 values ('RESET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RESET';
commit;
drop procedure f1;

create procedure f1 as begin goto RESIGNAL; null;<<RESIGNAL>> null; end;
/
insert into t2 values ('RESIGNAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RESIGNAL';
commit;
drop procedure f1;

create procedure f1 as begin goto RESTORE; null;<<RESTORE>> null; end;
/
insert into t2 values ('RESTORE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RESTORE';
commit;
drop procedure f1;

create procedure f1 as begin goto RESTRICT; null;<<RESTRICT>> null; end;
/
insert into t2 values ('RESTRICT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RESTRICT';
commit;
drop procedure f1;

create procedure f1 as begin goto RESUME; null;<<RESUME>> null; end;
/
insert into t2 values ('RESUME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RESUME';
commit;
drop procedure f1;

create procedure f1 as begin goto RETURNED_SQLSTATE; null;<<RETURNED_SQLSTATE>> null; end;
/
insert into t2 values ('RETURNED_SQLSTATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RETURNED_SQLSTATE';
commit;
drop procedure f1;

create procedure f1 as begin goto RETURN; null;<<RETURN>> null; end;
/
insert into t2 values ('RETURN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RETURN';
commit;
drop procedure f1;

create procedure f1 as begin goto RETURNING; null;<<RETURNING>> null; end;
/
insert into t2 values ('RETURNING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RETURNING';
commit;
drop procedure f1;

create procedure f1 as begin goto RETURNS; null;<<RETURNS>> null; end;
/
insert into t2 values ('RETURNS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RETURNS';
commit;
drop procedure f1;

create procedure f1 as begin goto REUSE; null;<<REUSE>> null; end;
/
insert into t2 values ('REUSE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REUSE';
commit;
drop procedure f1;

create procedure f1 as begin goto REVERSE; null;<<REVERSE>> null; end;
/
insert into t2 values ('REVERSE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REVERSE';
commit;
drop procedure f1;

create procedure f1 as begin goto REVOKE; null;<<REVOKE>> null; end;
/
insert into t2 values ('REVOKE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REVOKE';
commit;
drop procedure f1;

create procedure f1 as begin goto RIGHT; null;<<RIGHT>> null; end;
/
insert into t2 values ('RIGHT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RIGHT';
commit;
drop procedure f1;

create procedure f1 as begin goto RLIKE; null;<<RLIKE>> null; end;
/
insert into t2 values ('RLIKE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RLIKE';
commit;
drop procedure f1;

create procedure f1 as begin goto ROLE; null;<<ROLE>> null; end;
/
insert into t2 values ('ROLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROLE';
commit;
drop procedure f1;

create procedure f1 as begin goto ROLLBACK; null;<<ROLLBACK>> null; end;
/
insert into t2 values ('ROLLBACK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROLLBACK';
commit;
drop procedure f1;

create procedure f1 as begin goto ROLLUP; null;<<ROLLUP>> null; end;
/
insert into t2 values ('ROLLUP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROLLUP';
commit;
drop procedure f1;

create procedure f1 as begin goto ROUTINE; null;<<ROUTINE>> null; end;
/
insert into t2 values ('ROUTINE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROUTINE';
commit;
drop procedure f1;

create procedure f1 as begin goto ROW; null;<<ROW>> null; end;
/
insert into t2 values ('ROW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROW';
commit;
drop procedure f1;

create procedure f1 as begin goto ROWCOUNT; null;<<ROWCOUNT>> null; end;
/
insert into t2 values ('ROWCOUNT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROWCOUNT';
commit;
drop procedure f1;

create procedure f1 as begin goto ROWS; null;<<ROWS>> null; end;
/
insert into t2 values ('ROWS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROWS';
commit;
drop procedure f1;

create procedure f1 as begin goto ROW_COUNT; null;<<ROW_COUNT>> null; end;
/
insert into t2 values ('ROW_COUNT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROW_COUNT';
commit;
drop procedure f1;

create procedure f1 as begin goto ROW_FORMAT; null;<<ROW_FORMAT>> null; end;
/
insert into t2 values ('ROW_FORMAT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROW_FORMAT';
commit;
drop procedure f1;

create procedure f1 as begin goto RTREE; null;<<RTREE>> null; end;
/
insert into t2 values ('RTREE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RTREE';
commit;
drop procedure f1;

create procedure f1 as begin goto SAVEPOINT; null;<<SAVEPOINT>> null; end;
/
insert into t2 values ('SAVEPOINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SAVEPOINT';
commit;
drop procedure f1;

create procedure f1 as begin goto SCHEDULE; null;<<SCHEDULE>> null; end;
/
insert into t2 values ('SCHEDULE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SCHEDULE';
commit;
drop procedure f1;

create procedure f1 as begin goto SCHEMA; null;<<SCHEMA>> null; end;
/
insert into t2 values ('SCHEMA','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SCHEMA';
commit;
drop procedure f1;

create procedure f1 as begin goto SCHEMA_NAME; null;<<SCHEMA_NAME>> null; end;
/
insert into t2 values ('SCHEMA_NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SCHEMA_NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto SCHEMAS; null;<<SCHEMAS>> null; end;
/
insert into t2 values ('SCHEMAS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SCHEMAS';
commit;
drop procedure f1;

create procedure f1 as begin goto SECOND; null;<<SECOND>> null; end;
/
insert into t2 values ('SECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto SECOND_MICROSECOND; null;<<SECOND_MICROSECOND>> null; end;
/
insert into t2 values ('SECOND_MICROSECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SECOND_MICROSECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto SECURITY; null;<<SECURITY>> null; end;
/
insert into t2 values ('SECURITY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SECURITY';
commit;
drop procedure f1;

create procedure f1 as begin goto SELECT; null;<<SELECT>> null; end;
/
insert into t2 values ('SELECT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SELECT';
commit;
drop procedure f1;

create procedure f1 as begin goto SENSITIVE; null;<<SENSITIVE>> null; end;
/
insert into t2 values ('SENSITIVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SENSITIVE';
commit;
drop procedure f1;

create procedure f1 as begin goto SEPARATOR; null;<<SEPARATOR>> null; end;
/
insert into t2 values ('SEPARATOR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SEPARATOR';
commit;
drop procedure f1;

create procedure f1 as begin goto SERIAL; null;<<SERIAL>> null; end;
/
insert into t2 values ('SERIAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SERIAL';
commit;
drop procedure f1;

create procedure f1 as begin goto SERIALIZABLE; null;<<SERIALIZABLE>> null; end;
/
insert into t2 values ('SERIALIZABLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SERIALIZABLE';
commit;
drop procedure f1;

create procedure f1 as begin goto SESSION; null;<<SESSION>> null; end;
/
insert into t2 values ('SESSION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SESSION';
commit;
drop procedure f1;

create procedure f1 as begin goto SERVER; null;<<SERVER>> null; end;
/
insert into t2 values ('SERVER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SERVER';
commit;
drop procedure f1;

create procedure f1 as begin goto SET; null;<<SET>> null; end;
/
insert into t2 values ('SET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SET';
commit;
drop procedure f1;

create procedure f1 as begin goto SHARE; null;<<SHARE>> null; end;
/
insert into t2 values ('SHARE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SHARE';
commit;
drop procedure f1;

create procedure f1 as begin goto SHOW; null;<<SHOW>> null; end;
/
insert into t2 values ('SHOW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SHOW';
commit;
drop procedure f1;

create procedure f1 as begin goto SHUTDOWN; null;<<SHUTDOWN>> null; end;
/
insert into t2 values ('SHUTDOWN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SHUTDOWN';
commit;
drop procedure f1;

create procedure f1 as begin goto SIGNAL; null;<<SIGNAL>> null; end;
/
insert into t2 values ('SIGNAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SIGNAL';
commit;
drop procedure f1;

create procedure f1 as begin goto SIGNED; null;<<SIGNED>> null; end;
/
insert into t2 values ('SIGNED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SIGNED';
commit;
drop procedure f1;

create procedure f1 as begin goto SIMPLE; null;<<SIMPLE>> null; end;
/
insert into t2 values ('SIMPLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SIMPLE';
commit;
drop procedure f1;

create procedure f1 as begin goto SLAVE; null;<<SLAVE>> null; end;
/
insert into t2 values ('SLAVE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SLAVE';
commit;
drop procedure f1;

create procedure f1 as begin goto SLAVES; null;<<SLAVES>> null; end;
/
insert into t2 values ('SLAVES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SLAVES';
commit;
drop procedure f1;

create procedure f1 as begin goto SLAVE_POS; null;<<SLAVE_POS>> null; end;
/
insert into t2 values ('SLAVE_POS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SLAVE_POS';
commit;
drop procedure f1;

create procedure f1 as begin goto SLOW; null;<<SLOW>> null; end;
/
insert into t2 values ('SLOW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SLOW';
commit;
drop procedure f1;

create procedure f1 as begin goto SNAPSHOT; null;<<SNAPSHOT>> null; end;
/
insert into t2 values ('SNAPSHOT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SNAPSHOT';
commit;
drop procedure f1;

create procedure f1 as begin goto SMALLINT; null;<<SMALLINT>> null; end;
/
insert into t2 values ('SMALLINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SMALLINT';
commit;
drop procedure f1;

create procedure f1 as begin goto SOCKET; null;<<SOCKET>> null; end;
/
insert into t2 values ('SOCKET','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SOCKET';
commit;
drop procedure f1;

create procedure f1 as begin goto SOFT; null;<<SOFT>> null; end;
/
insert into t2 values ('SOFT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SOFT';
commit;
drop procedure f1;

create procedure f1 as begin goto SOME; null;<<SOME>> null; end;
/
insert into t2 values ('SOME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SOME';
commit;
drop procedure f1;

create procedure f1 as begin goto SONAME; null;<<SONAME>> null; end;
/
insert into t2 values ('SONAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SONAME';
commit;
drop procedure f1;

create procedure f1 as begin goto SOUNDS; null;<<SOUNDS>> null; end;
/
insert into t2 values ('SOUNDS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SOUNDS';
commit;
drop procedure f1;

create procedure f1 as begin goto SOURCE; null;<<SOURCE>> null; end;
/
insert into t2 values ('SOURCE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SOURCE';
commit;
drop procedure f1;

create procedure f1 as begin goto STORED; null;<<STORED>> null; end;
/
insert into t2 values ('STORED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STORED';
commit;
drop procedure f1;

create procedure f1 as begin goto SPATIAL; null;<<SPATIAL>> null; end;
/
insert into t2 values ('SPATIAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SPATIAL';
commit;
drop procedure f1;

create procedure f1 as begin goto SPECIFIC; null;<<SPECIFIC>> null; end;
/
insert into t2 values ('SPECIFIC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SPECIFIC';
commit;
drop procedure f1;

create procedure f1 as begin goto REF_SYSTEM_ID; null;<<REF_SYSTEM_ID>> null; end;
/
insert into t2 values ('REF_SYSTEM_ID','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='REF_SYSTEM_ID';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL; null;<<SQL>> null; end;
/
insert into t2 values ('SQL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL';
commit;
drop procedure f1;

create procedure f1 as begin goto SQLEXCEPTION; null;<<SQLEXCEPTION>> null; end;
/
insert into t2 values ('SQLEXCEPTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQLEXCEPTION';
commit;
drop procedure f1;

create procedure f1 as begin goto SQLSTATE; null;<<SQLSTATE>> null; end;
/
insert into t2 values ('SQLSTATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQLSTATE';
commit;
drop procedure f1;

create procedure f1 as begin goto SQLWARNING; null;<<SQLWARNING>> null; end;
/
insert into t2 values ('SQLWARNING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQLWARNING';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_BIG_RESULT; null;<<SQL_BIG_RESULT>> null; end;
/
insert into t2 values ('SQL_BIG_RESULT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_BIG_RESULT';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_BUFFER_RESULT; null;<<SQL_BUFFER_RESULT>> null; end;
/
insert into t2 values ('SQL_BUFFER_RESULT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_BUFFER_RESULT';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_CACHE; null;<<SQL_CACHE>> null; end;
/
insert into t2 values ('SQL_CACHE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_CACHE';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_CALC_FOUND_ROWS; null;<<SQL_CALC_FOUND_ROWS>> null; end;
/
insert into t2 values ('SQL_CALC_FOUND_ROWS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_CALC_FOUND_ROWS';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_NO_CACHE; null;<<SQL_NO_CACHE>> null; end;
/
insert into t2 values ('SQL_NO_CACHE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_NO_CACHE';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_SMALL_RESULT; null;<<SQL_SMALL_RESULT>> null; end;
/
insert into t2 values ('SQL_SMALL_RESULT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_SMALL_RESULT';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_THREAD; null;<<SQL_THREAD>> null; end;
/
insert into t2 values ('SQL_THREAD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_THREAD';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_SECOND; null;<<SQL_TSI_SECOND>> null; end;
/
insert into t2 values ('SQL_TSI_SECOND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_SECOND';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_MINUTE; null;<<SQL_TSI_MINUTE>> null; end;
/
insert into t2 values ('SQL_TSI_MINUTE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_MINUTE';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_HOUR; null;<<SQL_TSI_HOUR>> null; end;
/
insert into t2 values ('SQL_TSI_HOUR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_HOUR';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_DAY; null;<<SQL_TSI_DAY>> null; end;
/
insert into t2 values ('SQL_TSI_DAY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_DAY';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_WEEK; null;<<SQL_TSI_WEEK>> null; end;
/
insert into t2 values ('SQL_TSI_WEEK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_WEEK';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_MONTH; null;<<SQL_TSI_MONTH>> null; end;
/
insert into t2 values ('SQL_TSI_MONTH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_MONTH';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_QUARTER; null;<<SQL_TSI_QUARTER>> null; end;
/
insert into t2 values ('SQL_TSI_QUARTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_QUARTER';
commit;
drop procedure f1;

create procedure f1 as begin goto SQL_TSI_YEAR; null;<<SQL_TSI_YEAR>> null; end;
/
insert into t2 values ('SQL_TSI_YEAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SQL_TSI_YEAR';
commit;
drop procedure f1;

create procedure f1 as begin goto SSL; null;<<SSL>> null; end;
/
insert into t2 values ('SSL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SSL';
commit;
drop procedure f1;

create procedure f1 as begin goto START; null;<<START>> null; end;
/
insert into t2 values ('START','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='START';
commit;
drop procedure f1;

create procedure f1 as begin goto STARTING; null;<<STARTING>> null; end;
/
insert into t2 values ('STARTING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STARTING';
commit;
drop procedure f1;

create procedure f1 as begin goto STARTS; null;<<STARTS>> null; end;
/
insert into t2 values ('STARTS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STARTS';
commit;
drop procedure f1;

create procedure f1 as begin goto STATEMENT; null;<<STATEMENT>> null; end;
/
insert into t2 values ('STATEMENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STATEMENT';
commit;
drop procedure f1;

create procedure f1 as begin goto STATS_AUTO_RECALC; null;<<STATS_AUTO_RECALC>> null; end;
/
insert into t2 values ('STATS_AUTO_RECALC','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STATS_AUTO_RECALC';
commit;
drop procedure f1;

create procedure f1 as begin goto STATS_PERSISTENT; null;<<STATS_PERSISTENT>> null; end;
/
insert into t2 values ('STATS_PERSISTENT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STATS_PERSISTENT';
commit;
drop procedure f1;

create procedure f1 as begin goto STATS_SAMPLE_PAGES; null;<<STATS_SAMPLE_PAGES>> null; end;
/
insert into t2 values ('STATS_SAMPLE_PAGES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STATS_SAMPLE_PAGES';
commit;
drop procedure f1;

create procedure f1 as begin goto STATUS; null;<<STATUS>> null; end;
/
insert into t2 values ('STATUS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STATUS';
commit;
drop procedure f1;

create procedure f1 as begin goto STOP; null;<<STOP>> null; end;
/
insert into t2 values ('STOP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STOP';
commit;
drop procedure f1;

create procedure f1 as begin goto STORAGE; null;<<STORAGE>> null; end;
/
insert into t2 values ('STORAGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STORAGE';
commit;
drop procedure f1;

create procedure f1 as begin goto STRAIGHT_JOIN; null;<<STRAIGHT_JOIN>> null; end;
/
insert into t2 values ('STRAIGHT_JOIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STRAIGHT_JOIN';
commit;
drop procedure f1;

create procedure f1 as begin goto STRING; null;<<STRING>> null; end;
/
insert into t2 values ('STRING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STRING';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBCLASS_ORIGIN; null;<<SUBCLASS_ORIGIN>> null; end;
/
insert into t2 values ('SUBCLASS_ORIGIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBCLASS_ORIGIN';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBJECT; null;<<SUBJECT>> null; end;
/
insert into t2 values ('SUBJECT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBJECT';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBPARTITION; null;<<SUBPARTITION>> null; end;
/
insert into t2 values ('SUBPARTITION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBPARTITION';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBPARTITIONS; null;<<SUBPARTITIONS>> null; end;
/
insert into t2 values ('SUBPARTITIONS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBPARTITIONS';
commit;
drop procedure f1;

create procedure f1 as begin goto SUPER; null;<<SUPER>> null; end;
/
insert into t2 values ('SUPER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUPER';
commit;
drop procedure f1;

create procedure f1 as begin goto SUSPEND; null;<<SUSPEND>> null; end;
/
insert into t2 values ('SUSPEND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUSPEND';
commit;
drop procedure f1;

create procedure f1 as begin goto SWAPS; null;<<SWAPS>> null; end;
/
insert into t2 values ('SWAPS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SWAPS';
commit;
drop procedure f1;

create procedure f1 as begin goto SWITCHES; null;<<SWITCHES>> null; end;
/
insert into t2 values ('SWITCHES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SWITCHES';
commit;
drop procedure f1;

create procedure f1 as begin goto TABLE; null;<<TABLE>> null; end;
/
insert into t2 values ('TABLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TABLE';
commit;
drop procedure f1;

create procedure f1 as begin goto TABLE_NAME; null;<<TABLE_NAME>> null; end;
/
insert into t2 values ('TABLE_NAME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TABLE_NAME';
commit;
drop procedure f1;

create procedure f1 as begin goto TABLES; null;<<TABLES>> null; end;
/
insert into t2 values ('TABLES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TABLES';
commit;
drop procedure f1;

create procedure f1 as begin goto TABLESPACE; null;<<TABLESPACE>> null; end;
/
insert into t2 values ('TABLESPACE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TABLESPACE';
commit;
drop procedure f1;

create procedure f1 as begin goto TABLE_CHECKSUM; null;<<TABLE_CHECKSUM>> null; end;
/
insert into t2 values ('TABLE_CHECKSUM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TABLE_CHECKSUM';
commit;
drop procedure f1;

create procedure f1 as begin goto TEMPORARY; null;<<TEMPORARY>> null; end;
/
insert into t2 values ('TEMPORARY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TEMPORARY';
commit;
drop procedure f1;

create procedure f1 as begin goto TEMPTABLE; null;<<TEMPTABLE>> null; end;
/
insert into t2 values ('TEMPTABLE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TEMPTABLE';
commit;
drop procedure f1;

create procedure f1 as begin goto TERMINATED; null;<<TERMINATED>> null; end;
/
insert into t2 values ('TERMINATED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TERMINATED';
commit;
drop procedure f1;

create procedure f1 as begin goto TEXT; null;<<TEXT>> null; end;
/
insert into t2 values ('TEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto THAN; null;<<THAN>> null; end;
/
insert into t2 values ('THAN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='THAN';
commit;
drop procedure f1;

create procedure f1 as begin goto THEN; null;<<THEN>> null; end;
/
insert into t2 values ('THEN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='THEN';
commit;
drop procedure f1;

create procedure f1 as begin goto TIES; null;<<TIES>> null; end;
/
insert into t2 values ('TIES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TIES';
commit;
drop procedure f1;

create procedure f1 as begin goto TIME; null;<<TIME>> null; end;
/
insert into t2 values ('TIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TIME';
commit;
drop procedure f1;

create procedure f1 as begin goto TIMESTAMP; null;<<TIMESTAMP>> null; end;
/
insert into t2 values ('TIMESTAMP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TIMESTAMP';
commit;
drop procedure f1;

create procedure f1 as begin goto TIMESTAMPADD; null;<<TIMESTAMPADD>> null; end;
/
insert into t2 values ('TIMESTAMPADD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TIMESTAMPADD';
commit;
drop procedure f1;

create procedure f1 as begin goto TIMESTAMPDIFF; null;<<TIMESTAMPDIFF>> null; end;
/
insert into t2 values ('TIMESTAMPDIFF','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TIMESTAMPDIFF';
commit;
drop procedure f1;

create procedure f1 as begin goto TINYBLOB; null;<<TINYBLOB>> null; end;
/
insert into t2 values ('TINYBLOB','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TINYBLOB';
commit;
drop procedure f1;

create procedure f1 as begin goto TINYINT; null;<<TINYINT>> null; end;
/
insert into t2 values ('TINYINT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TINYINT';
commit;
drop procedure f1;

create procedure f1 as begin goto TINYTEXT; null;<<TINYTEXT>> null; end;
/
insert into t2 values ('TINYTEXT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TINYTEXT';
commit;
drop procedure f1;

create procedure f1 as begin goto TO; null;<<TO>> null; end;
/
insert into t2 values ('TO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TO';
commit;
drop procedure f1;

create procedure f1 as begin goto TRAILING; null;<<TRAILING>> null; end;
/
insert into t2 values ('TRAILING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRAILING';
commit;
drop procedure f1;

create procedure f1 as begin goto TRANSACTION; null;<<TRANSACTION>> null; end;
/
insert into t2 values ('TRANSACTION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRANSACTION';
commit;
drop procedure f1;

create procedure f1 as begin goto TRANSACTIONAL; null;<<TRANSACTIONAL>> null; end;
/
insert into t2 values ('TRANSACTIONAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRANSACTIONAL';
commit;
drop procedure f1;

create procedure f1 as begin goto TRIGGER; null;<<TRIGGER>> null; end;
/
insert into t2 values ('TRIGGER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRIGGER';
commit;
drop procedure f1;

create procedure f1 as begin goto TRIGGERS; null;<<TRIGGERS>> null; end;
/
insert into t2 values ('TRIGGERS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRIGGERS';
commit;
drop procedure f1;

create procedure f1 as begin goto TRUE; null;<<TRUE>> null; end;
/
insert into t2 values ('TRUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRUE';
commit;
drop procedure f1;

create procedure f1 as begin goto TRUNCATE; null;<<TRUNCATE>> null; end;
/
insert into t2 values ('TRUNCATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRUNCATE';
commit;
drop procedure f1;

create procedure f1 as begin goto TYPE; null;<<TYPE>> null; end;
/
insert into t2 values ('TYPE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TYPE';
commit;
drop procedure f1;

create procedure f1 as begin goto TYPES; null;<<TYPES>> null; end;
/
insert into t2 values ('TYPES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TYPES';
commit;
drop procedure f1;

create procedure f1 as begin goto UNBOUNDED; null;<<UNBOUNDED>> null; end;
/
insert into t2 values ('UNBOUNDED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNBOUNDED';
commit;
drop procedure f1;

create procedure f1 as begin goto UNCOMMITTED; null;<<UNCOMMITTED>> null; end;
/
insert into t2 values ('UNCOMMITTED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNCOMMITTED';
commit;
drop procedure f1;

create procedure f1 as begin goto UNDEFINED; null;<<UNDEFINED>> null; end;
/
insert into t2 values ('UNDEFINED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNDEFINED';
commit;
drop procedure f1;

create procedure f1 as begin goto UNDO_BUFFER_SIZE; null;<<UNDO_BUFFER_SIZE>> null; end;
/
insert into t2 values ('UNDO_BUFFER_SIZE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNDO_BUFFER_SIZE';
commit;
drop procedure f1;

create procedure f1 as begin goto UNDOFILE; null;<<UNDOFILE>> null; end;
/
insert into t2 values ('UNDOFILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNDOFILE';
commit;
drop procedure f1;

create procedure f1 as begin goto UNDO; null;<<UNDO>> null; end;
/
insert into t2 values ('UNDO','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNDO';
commit;
drop procedure f1;

create procedure f1 as begin goto UNICODE; null;<<UNICODE>> null; end;
/
insert into t2 values ('UNICODE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNICODE';
commit;
drop procedure f1;

create procedure f1 as begin goto UNION; null;<<UNION>> null; end;
/
insert into t2 values ('UNION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNION';
commit;
drop procedure f1;

create procedure f1 as begin goto UNIQUE; null;<<UNIQUE>> null; end;
/
insert into t2 values ('UNIQUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNIQUE';
commit;
drop procedure f1;

create procedure f1 as begin goto UNKNOWN; null;<<UNKNOWN>> null; end;
/
insert into t2 values ('UNKNOWN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNKNOWN';
commit;
drop procedure f1;

create procedure f1 as begin goto UNLOCK; null;<<UNLOCK>> null; end;
/
insert into t2 values ('UNLOCK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNLOCK';
commit;
drop procedure f1;

create procedure f1 as begin goto UNINSTALL; null;<<UNINSTALL>> null; end;
/
insert into t2 values ('UNINSTALL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNINSTALL';
commit;
drop procedure f1;

create procedure f1 as begin goto UNSIGNED; null;<<UNSIGNED>> null; end;
/
insert into t2 values ('UNSIGNED','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNSIGNED';
commit;
drop procedure f1;

create procedure f1 as begin goto UNTIL; null;<<UNTIL>> null; end;
/
insert into t2 values ('UNTIL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UNTIL';
commit;
drop procedure f1;

create procedure f1 as begin goto UPDATE; null;<<UPDATE>> null; end;
/
insert into t2 values ('UPDATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UPDATE';
commit;
drop procedure f1;

create procedure f1 as begin goto UPGRADE; null;<<UPGRADE>> null; end;
/
insert into t2 values ('UPGRADE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UPGRADE';
commit;
drop procedure f1;

create procedure f1 as begin goto USAGE; null;<<USAGE>> null; end;
/
insert into t2 values ('USAGE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='USAGE';
commit;
drop procedure f1;

create procedure f1 as begin goto USE; null;<<USE>> null; end;
/
insert into t2 values ('USE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='USE';
commit;
drop procedure f1;

create procedure f1 as begin goto USER; null;<<USER>> null; end;
/
insert into t2 values ('USER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='USER';
commit;
drop procedure f1;

create procedure f1 as begin goto USER_RESOURCES; null;<<USER_RESOURCES>> null; end;
/
insert into t2 values ('USER_RESOURCES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='USER_RESOURCES';
commit;
drop procedure f1;

create procedure f1 as begin goto USE_FRM; null;<<USE_FRM>> null; end;
/
insert into t2 values ('USE_FRM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='USE_FRM';
commit;
drop procedure f1;

create procedure f1 as begin goto USING; null;<<USING>> null; end;
/
insert into t2 values ('USING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='USING';
commit;
drop procedure f1;

create procedure f1 as begin goto UTC_DATE; null;<<UTC_DATE>> null; end;
/
insert into t2 values ('UTC_DATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UTC_DATE';
commit;
drop procedure f1;

create procedure f1 as begin goto UTC_TIME; null;<<UTC_TIME>> null; end;
/
insert into t2 values ('UTC_TIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UTC_TIME';
commit;
drop procedure f1;

create procedure f1 as begin goto UTC_TIMESTAMP; null;<<UTC_TIMESTAMP>> null; end;
/
insert into t2 values ('UTC_TIMESTAMP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='UTC_TIMESTAMP';
commit;
drop procedure f1;

create procedure f1 as begin goto VALUE; null;<<VALUE>> null; end;
/
insert into t2 values ('VALUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VALUE';
commit;
drop procedure f1;

create procedure f1 as begin goto VALUES; null;<<VALUES>> null; end;
/
insert into t2 values ('VALUES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VALUES';
commit;
drop procedure f1;

create procedure f1 as begin goto VARBINARY; null;<<VARBINARY>> null; end;
/
insert into t2 values ('VARBINARY','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARBINARY';
commit;
drop procedure f1;

create procedure f1 as begin goto VARCHAR; null;<<VARCHAR>> null; end;
/
insert into t2 values ('VARCHAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARCHAR';
commit;
drop procedure f1;

create procedure f1 as begin goto VARCHARACTER; null;<<VARCHARACTER>> null; end;
/
insert into t2 values ('VARCHARACTER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARCHARACTER';
commit;
drop procedure f1;

create procedure f1 as begin goto VARCHAR2; null;<<VARCHAR2>> null; end;
/
insert into t2 values ('VARCHAR2','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARCHAR2';
commit;
drop procedure f1;

create procedure f1 as begin goto VARIABLES; null;<<VARIABLES>> null; end;
/
insert into t2 values ('VARIABLES','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARIABLES';
commit;
drop procedure f1;

create procedure f1 as begin goto VARYING; null;<<VARYING>> null; end;
/
insert into t2 values ('VARYING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARYING';
commit;
drop procedure f1;

create procedure f1 as begin goto VIA; null;<<VIA>> null; end;
/
insert into t2 values ('VIA','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VIA';
commit;
drop procedure f1;

create procedure f1 as begin goto VIEW; null;<<VIEW>> null; end;
/
insert into t2 values ('VIEW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VIEW';
commit;
drop procedure f1;

create procedure f1 as begin goto VIRTUAL; null;<<VIRTUAL>> null; end;
/
insert into t2 values ('VIRTUAL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VIRTUAL';
commit;
drop procedure f1;

create procedure f1 as begin goto WAIT; null;<<WAIT>> null; end;
/
insert into t2 values ('WAIT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WAIT';
commit;
drop procedure f1;

create procedure f1 as begin goto WARNINGS; null;<<WARNINGS>> null; end;
/
insert into t2 values ('WARNINGS','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WARNINGS';
commit;
drop procedure f1;

create procedure f1 as begin goto WEEK; null;<<WEEK>> null; end;
/
insert into t2 values ('WEEK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WEEK';
commit;
drop procedure f1;

create procedure f1 as begin goto WEIGHT_STRING; null;<<WEIGHT_STRING>> null; end;
/
insert into t2 values ('WEIGHT_STRING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WEIGHT_STRING';
commit;
drop procedure f1;

create procedure f1 as begin goto WHEN; null;<<WHEN>> null; end;
/
insert into t2 values ('WHEN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WHEN';
commit;
drop procedure f1;

create procedure f1 as begin goto WHERE; null;<<WHERE>> null; end;
/
insert into t2 values ('WHERE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WHERE';
commit;
drop procedure f1;

create procedure f1 as begin goto WHILE; null;<<WHILE>> null; end;
/
insert into t2 values ('WHILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WHILE';
commit;
drop procedure f1;

create procedure f1 as begin goto WINDOW; null;<<WINDOW>> null; end;
/
insert into t2 values ('WINDOW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WINDOW';
commit;
drop procedure f1;

create procedure f1 as begin goto WITH; null;<<WITH>> null; end;
/
insert into t2 values ('WITH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WITH';
commit;
drop procedure f1;

create procedure f1 as begin goto WORK; null;<<WORK>> null; end;
/
insert into t2 values ('WORK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WORK';
commit;
drop procedure f1;

create procedure f1 as begin goto WRAPPER; null;<<WRAPPER>> null; end;
/
insert into t2 values ('WRAPPER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WRAPPER';
commit;
drop procedure f1;

create procedure f1 as begin goto WRITE; null;<<WRITE>> null; end;
/
insert into t2 values ('WRITE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='WRITE';
commit;
drop procedure f1;

create procedure f1 as begin goto X509; null;<<X509>> null; end;
/
insert into t2 values ('X509','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='X509';
commit;
drop procedure f1;

create procedure f1 as begin goto XOR; null;<<XOR>> null; end;
/
insert into t2 values ('XOR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='XOR';
commit;
drop procedure f1;

create procedure f1 as begin goto XA; null;<<XA>> null; end;
/
insert into t2 values ('XA','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='XA';
commit;
drop procedure f1;

create procedure f1 as begin goto XML; null;<<XML>> null; end;
/
insert into t2 values ('XML','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='XML';
commit;
drop procedure f1;

create procedure f1 as begin goto YEAR; null;<<YEAR>> null; end;
/
insert into t2 values ('YEAR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='YEAR';
commit;
drop procedure f1;

create procedure f1 as begin goto YEAR_MONTH; null;<<YEAR_MONTH>> null; end;
/
insert into t2 values ('YEAR_MONTH','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='YEAR_MONTH';
commit;
drop procedure f1;

create procedure f1 as begin goto ZEROFILL; null;<<ZEROFILL>> null; end;
/
insert into t2 values ('ZEROFILL','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ZEROFILL';
commit;
drop procedure f1;

create procedure f1 as begin goto ADDDATE; null;<<ADDDATE>> null; end;
/
insert into t2 values ('ADDDATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ADDDATE';
commit;
drop procedure f1;

create procedure f1 as begin goto BIT_AND; null;<<BIT_AND>> null; end;
/
insert into t2 values ('BIT_AND','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BIT_AND';
commit;
drop procedure f1;

create procedure f1 as begin goto BIT_OR; null;<<BIT_OR>> null; end;
/
insert into t2 values ('BIT_OR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BIT_OR';
commit;
drop procedure f1;

create procedure f1 as begin goto BIT_XOR; null;<<BIT_XOR>> null; end;
/
insert into t2 values ('BIT_XOR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='BIT_XOR';
commit;
drop procedure f1;

create procedure f1 as begin goto CAST; null;<<CAST>> null; end;
/
insert into t2 values ('CAST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CAST';
commit;
drop procedure f1;

create procedure f1 as begin goto COUNT; null;<<COUNT>> null; end;
/
insert into t2 values ('COUNT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='COUNT';
commit;
drop procedure f1;

create procedure f1 as begin goto CUME_DIST; null;<<CUME_DIST>> null; end;
/
insert into t2 values ('CUME_DIST','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CUME_DIST';
commit;
drop procedure f1;

create procedure f1 as begin goto CURDATE; null;<<CURDATE>> null; end;
/
insert into t2 values ('CURDATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURDATE';
commit;
drop procedure f1;

create procedure f1 as begin goto CURTIME; null;<<CURTIME>> null; end;
/
insert into t2 values ('CURTIME','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='CURTIME';
commit;
drop procedure f1;

create procedure f1 as begin goto DATE_ADD; null;<<DATE_ADD>> null; end;
/
insert into t2 values ('DATE_ADD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATE_ADD';
commit;
drop procedure f1;

create procedure f1 as begin goto DATE_SUB; null;<<DATE_SUB>> null; end;
/
insert into t2 values ('DATE_SUB','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DATE_SUB';
commit;
drop procedure f1;

create procedure f1 as begin goto DECODE; null;<<DECODE>> null; end;
/
insert into t2 values ('DECODE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DECODE';
commit;
drop procedure f1;

create procedure f1 as begin goto DENSE_RANK; null;<<DENSE_RANK>> null; end;
/
insert into t2 values ('DENSE_RANK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='DENSE_RANK';
commit;
drop procedure f1;

create procedure f1 as begin goto EXTRACT; null;<<EXTRACT>> null; end;
/
insert into t2 values ('EXTRACT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='EXTRACT';
commit;
drop procedure f1;

create procedure f1 as begin goto FIRST_VALUE; null;<<FIRST_VALUE>> null; end;
/
insert into t2 values ('FIRST_VALUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='FIRST_VALUE';
commit;
drop procedure f1;

create procedure f1 as begin goto GROUP_CONCAT; null;<<GROUP_CONCAT>> null; end;
/
insert into t2 values ('GROUP_CONCAT','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='GROUP_CONCAT';
commit;
drop procedure f1;

create procedure f1 as begin goto LAG; null;<<LAG>> null; end;
/
insert into t2 values ('LAG','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LAG';
commit;
drop procedure f1;

create procedure f1 as begin goto LEAD; null;<<LEAD>> null; end;
/
insert into t2 values ('LEAD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='LEAD';
commit;
drop procedure f1;

create procedure f1 as begin goto MAX; null;<<MAX>> null; end;
/
insert into t2 values ('MAX','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MAX';
commit;
drop procedure f1;

create procedure f1 as begin goto MID; null;<<MID>> null; end;
/
insert into t2 values ('MID','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MID';
commit;
drop procedure f1;

create procedure f1 as begin goto MIN; null;<<MIN>> null; end;
/
insert into t2 values ('MIN','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='MIN';
commit;
drop procedure f1;

create procedure f1 as begin goto NOW; null;<<NOW>> null; end;
/
insert into t2 values ('NOW','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NOW';
commit;
drop procedure f1;

create procedure f1 as begin goto NTH_VALUE; null;<<NTH_VALUE>> null; end;
/
insert into t2 values ('NTH_VALUE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NTH_VALUE';
commit;
drop procedure f1;

create procedure f1 as begin goto NTILE; null;<<NTILE>> null; end;
/
insert into t2 values ('NTILE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='NTILE';
commit;
drop procedure f1;

create procedure f1 as begin goto POSITION; null;<<POSITION>> null; end;
/
insert into t2 values ('POSITION','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='POSITION';
commit;
drop procedure f1;

create procedure f1 as begin goto PERCENT_RANK; null;<<PERCENT_RANK>> null; end;
/
insert into t2 values ('PERCENT_RANK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='PERCENT_RANK';
commit;
drop procedure f1;

create procedure f1 as begin goto RANK; null;<<RANK>> null; end;
/
insert into t2 values ('RANK','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='RANK';
commit;
drop procedure f1;

create procedure f1 as begin goto ROW_NUMBER; null;<<ROW_NUMBER>> null; end;
/
insert into t2 values ('ROW_NUMBER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='ROW_NUMBER';
commit;
drop procedure f1;

create procedure f1 as begin goto SESSION_USER; null;<<SESSION_USER>> null; end;
/
insert into t2 values ('SESSION_USER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SESSION_USER';
commit;
drop procedure f1;

create procedure f1 as begin goto STD; null;<<STD>> null; end;
/
insert into t2 values ('STD','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STD';
commit;
drop procedure f1;

create procedure f1 as begin goto STDDEV; null;<<STDDEV>> null; end;
/
insert into t2 values ('STDDEV','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STDDEV';
commit;
drop procedure f1;

create procedure f1 as begin goto STDDEV_POP; null;<<STDDEV_POP>> null; end;
/
insert into t2 values ('STDDEV_POP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STDDEV_POP';
commit;
drop procedure f1;

create procedure f1 as begin goto STDDEV_SAMP; null;<<STDDEV_SAMP>> null; end;
/
insert into t2 values ('STDDEV_SAMP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='STDDEV_SAMP';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBDATE; null;<<SUBDATE>> null; end;
/
insert into t2 values ('SUBDATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBDATE';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBSTR; null;<<SUBSTR>> null; end;
/
insert into t2 values ('SUBSTR','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBSTR';
commit;
drop procedure f1;

create procedure f1 as begin goto SUBSTRING; null;<<SUBSTRING>> null; end;
/
insert into t2 values ('SUBSTRING','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUBSTRING';
commit;
drop procedure f1;

create procedure f1 as begin goto SUM; null;<<SUM>> null; end;
/
insert into t2 values ('SUM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SUM';
commit;
drop procedure f1;

create procedure f1 as begin goto SYSDATE; null;<<SYSDATE>> null; end;
/
insert into t2 values ('SYSDATE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SYSDATE';
commit;
drop procedure f1;

create procedure f1 as begin goto SYSTEM_USER; null;<<SYSTEM_USER>> null; end;
/
insert into t2 values ('SYSTEM_USER','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='SYSTEM_USER';
commit;
drop procedure f1;

create procedure f1 as begin goto TRIM; null;<<TRIM>> null; end;
/
insert into t2 values ('TRIM','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='TRIM';
commit;
drop procedure f1;

create procedure f1 as begin goto VARIANCE; null;<<VARIANCE>> null; end;
/
insert into t2 values ('VARIANCE','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VARIANCE';
commit;
drop procedure f1;

create procedure f1 as begin goto VAR_POP; null;<<VAR_POP>> null; end;
/
insert into t2 values ('VAR_POP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VAR_POP';
commit;
drop procedure f1;

create procedure f1 as begin goto VAR_SAMP; null;<<VAR_SAMP>> null; end;
/
insert into t2 values ('VAR_SAMP','??');
commit;
update t2 set result=(select decode(status,'VALID','OK','KO')
                        from user_objects
                       where object_name='F1'
                         and object_type='PROCEDURE')
 where name='VAR_SAMP';
commit;
drop procedure f1;


select result,name from t2 order by name asc ;
drop table t2;
