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

create or replace procedure f1 as ACCESSIBLE integer;begin ACCESSIBLE:=1; 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 or replace procedure f1 as ACTION integer;begin ACTION:=1; 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 or replace procedure f1 as ADD integer;begin ADD:=1; 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 or replace procedure f1 as ADMIN integer;begin ADMIN:=1; 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 or replace procedure f1 as AFTER integer;begin AFTER:=1; 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 or replace procedure f1 as AGAINST integer;begin AGAINST:=1; 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 or replace procedure f1 as AGGREGATE integer;begin AGGREGATE:=1; 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 or replace procedure f1 as ALL integer;begin ALL:=1; 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 or replace procedure f1 as ALGORITHM integer;begin ALGORITHM:=1; 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 or replace procedure f1 as ALTER integer;begin ALTER:=1; 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 or replace procedure f1 as ALWAYS integer;begin ALWAYS:=1; 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 or replace procedure f1 as ANALYZE integer;begin ANALYZE:=1; 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 or replace procedure f1 as AND integer;begin AND:=1; 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 or replace procedure f1 as ANY integer;begin ANY:=1; 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 or replace procedure f1 as AS integer;begin AS:=1; 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 or replace procedure f1 as ASC integer;begin ASC:=1; 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 or replace procedure f1 as ASCII integer;begin ASCII:=1; 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 or replace procedure f1 as ASENSITIVE integer;begin ASENSITIVE:=1; 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 or replace procedure f1 as AT integer;begin AT:=1; 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 or replace procedure f1 as ATOMIC integer;begin ATOMIC:=1; 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 or replace procedure f1 as AUTHORS integer;begin AUTHORS:=1; 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 or replace procedure f1 as AUTO_INCREMENT integer;begin AUTO_INCREMENT:=1; 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 or replace procedure f1 as AUTOEXTEND_SIZE integer;begin AUTOEXTEND_SIZE:=1; 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 or replace procedure f1 as AUTO integer;begin AUTO:=1; 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 or replace procedure f1 as AVG integer;begin AVG:=1; 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 or replace procedure f1 as AVG_ROW_LENGTH integer;begin AVG_ROW_LENGTH:=1; 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 or replace procedure f1 as BACKUP integer;begin BACKUP:=1; 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 or replace procedure f1 as BEFORE integer;begin BEFORE:=1; 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 or replace procedure f1 as BEGIN integer;begin BEGIN:=1; 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 or replace procedure f1 as BETWEEN integer;begin BETWEEN:=1; 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 or replace procedure f1 as BIGINT integer;begin BIGINT:=1; 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 or replace procedure f1 as BINARY integer;begin BINARY:=1; 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 or replace procedure f1 as BINLOG integer;begin BINLOG:=1; 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 or replace procedure f1 as BIT integer;begin BIT:=1; 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 or replace procedure f1 as BLOB integer;begin BLOB:=1; 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 or replace procedure f1 as BLOCK integer;begin BLOCK:=1; 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 or replace procedure f1 as BODY integer;begin BODY:=1; 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 or replace procedure f1 as BOOL integer;begin BOOL:=1; 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 or replace procedure f1 as BOOLEAN integer;begin BOOLEAN:=1; 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 or replace procedure f1 as BOTH integer;begin BOTH:=1; 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 or replace procedure f1 as BTREE integer;begin BTREE:=1; 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 or replace procedure f1 as BY integer;begin BY:=1; 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 or replace procedure f1 as BYTE integer;begin BYTE:=1; 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 or replace procedure f1 as CACHE integer;begin CACHE:=1; 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 or replace procedure f1 as CALL integer;begin CALL:=1; 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 or replace procedure f1 as CASCADE integer;begin CASCADE:=1; 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 or replace procedure f1 as CASCADED integer;begin CASCADED:=1; 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 or replace procedure f1 as CASE integer;begin CASE:=1; 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 or replace procedure f1 as CATALOG_NAME integer;begin CATALOG_NAME:=1; 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 or replace procedure f1 as CHAIN integer;begin CHAIN:=1; 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 or replace procedure f1 as CHANGE integer;begin CHANGE:=1; 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 or replace procedure f1 as CHANGED integer;begin CHANGED:=1; 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 or replace procedure f1 as CHAR integer;begin CHAR:=1; 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 or replace procedure f1 as CHARACTER integer;begin CHARACTER:=1; 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 or replace procedure f1 as CHARSET integer;begin CHARSET:=1; 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 or replace procedure f1 as CHECK integer;begin CHECK:=1; 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 or replace procedure f1 as CHECKPOINT integer;begin CHECKPOINT:=1; 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 or replace procedure f1 as CHECKSUM integer;begin CHECKSUM:=1; 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 or replace procedure f1 as CIPHER integer;begin CIPHER:=1; 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 or replace procedure f1 as CLASS_ORIGIN integer;begin CLASS_ORIGIN:=1; 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 or replace procedure f1 as CLIENT integer;begin CLIENT:=1; 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 or replace procedure f1 as CLOB integer;begin CLOB:=1; 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 or replace procedure f1 as CLOSE integer;begin CLOSE:=1; 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 or replace procedure f1 as COALESCE integer;begin COALESCE:=1; 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 or replace procedure f1 as CODE integer;begin CODE:=1; 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 or replace procedure f1 as COLLATE integer;begin COLLATE:=1; 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 or replace procedure f1 as COLLATION integer;begin COLLATION:=1; 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 or replace procedure f1 as COLUMN integer;begin COLUMN:=1; 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 or replace procedure f1 as COLUMN_NAME integer;begin COLUMN_NAME:=1; 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 or replace procedure f1 as COLUMNS integer;begin COLUMNS:=1; 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 or replace procedure f1 as COLUMN_ADD integer;begin COLUMN_ADD:=1; 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 or replace procedure f1 as COLUMN_CHECK integer;begin COLUMN_CHECK:=1; 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 or replace procedure f1 as COLUMN_CREATE integer;begin COLUMN_CREATE:=1; 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 or replace procedure f1 as COLUMN_DELETE integer;begin COLUMN_DELETE:=1; 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 or replace procedure f1 as COLUMN_GET integer;begin COLUMN_GET:=1; 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 or replace procedure f1 as COMMENT integer;begin COMMENT:=1; 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 or replace procedure f1 as COMMIT integer;begin COMMIT:=1; 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 or replace procedure f1 as COMMITTED integer;begin COMMITTED:=1; 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 or replace procedure f1 as COMPACT integer;begin COMPACT:=1; 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 or replace procedure f1 as COMPLETION integer;begin COMPLETION:=1; 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 or replace procedure f1 as COMPRESSED integer;begin COMPRESSED:=1; 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 or replace procedure f1 as CONCURRENT integer;begin CONCURRENT:=1; 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 or replace procedure f1 as CONDITION integer;begin CONDITION:=1; 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 or replace procedure f1 as CONNECTION integer;begin CONNECTION:=1; 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 or replace procedure f1 as CONSISTENT integer;begin CONSISTENT:=1; 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 or replace procedure f1 as CONSTRAINT integer;begin CONSTRAINT:=1; 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 or replace procedure f1 as CONSTRAINT_CATALOG integer;begin CONSTRAINT_CATALOG:=1; 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 or replace procedure f1 as CONSTRAINT_NAME integer;begin CONSTRAINT_NAME:=1; 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 or replace procedure f1 as CONSTRAINT_SCHEMA integer;begin CONSTRAINT_SCHEMA:=1; 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 or replace procedure f1 as CONTAINS integer;begin CONTAINS:=1; 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 or replace procedure f1 as CONTEXT integer;begin CONTEXT:=1; 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 or replace procedure f1 as CONTINUE integer;begin CONTINUE:=1; 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 or replace procedure f1 as CONTRIBUTORS integer;begin CONTRIBUTORS:=1; 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 or replace procedure f1 as CONVERT integer;begin CONVERT:=1; 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 or replace procedure f1 as CPU integer;begin CPU:=1; 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 or replace procedure f1 as CREATE integer;begin CREATE:=1; 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 or replace procedure f1 as CROSS integer;begin CROSS:=1; 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 or replace procedure f1 as CUBE integer;begin CUBE:=1; 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 or replace procedure f1 as CURRENT integer;begin CURRENT:=1; 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 or replace procedure f1 as CURRENT_DATE integer;begin CURRENT_DATE:=1; 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 or replace procedure f1 as CURRENT_POS integer;begin CURRENT_POS:=1; 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 or replace procedure f1 as CURRENT_ROLE integer;begin CURRENT_ROLE:=1; 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 or replace procedure f1 as CURRENT_TIME integer;begin CURRENT_TIME:=1; 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 or replace procedure f1 as CURRENT_TIMESTAMP integer;begin CURRENT_TIMESTAMP:=1; 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 or replace procedure f1 as CURRENT_USER integer;begin CURRENT_USER:=1; 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 or replace procedure f1 as CURSOR integer;begin CURSOR:=1; 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 or replace procedure f1 as CURSOR_NAME integer;begin CURSOR_NAME:=1; 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 or replace procedure f1 as DATA integer;begin DATA:=1; 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 or replace procedure f1 as DATABASE integer;begin DATABASE:=1; 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 or replace procedure f1 as DATABASES integer;begin DATABASES:=1; 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 or replace procedure f1 as DATAFILE integer;begin DATAFILE:=1; 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 or replace procedure f1 as DATE integer;begin DATE:=1; 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 or replace procedure f1 as DATETIME integer;begin DATETIME:=1; 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 or replace procedure f1 as DAY integer;begin DAY:=1; 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 or replace procedure f1 as DAY_HOUR integer;begin DAY_HOUR:=1; 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 or replace procedure f1 as DAY_MICROSECOND integer;begin DAY_MICROSECOND:=1; 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 or replace procedure f1 as DAY_MINUTE integer;begin DAY_MINUTE:=1; 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 or replace procedure f1 as DAY_SECOND integer;begin DAY_SECOND:=1; 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 or replace procedure f1 as DEALLOCATE integer;begin DEALLOCATE:=1; 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 or replace procedure f1 as DEC integer;begin DEC:=1; 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 or replace procedure f1 as DECIMAL integer;begin DECIMAL:=1; 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 or replace procedure f1 as DECLARE integer;begin DECLARE:=1; 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 or replace procedure f1 as DEFAULT integer;begin DEFAULT:=1; 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 or replace procedure f1 as DEFINER integer;begin DEFINER:=1; 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 or replace procedure f1 as DELAYED integer;begin DELAYED:=1; 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 or replace procedure f1 as DELAY_KEY_WRITE integer;begin DELAY_KEY_WRITE:=1; 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 or replace procedure f1 as DELETE integer;begin DELETE:=1; 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 or replace procedure f1 as DESC integer;begin DESC:=1; 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 or replace procedure f1 as DESCRIBE integer;begin DESCRIBE:=1; 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 or replace procedure f1 as DES_KEY_FILE integer;begin DES_KEY_FILE:=1; 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 or replace procedure f1 as DETERMINISTIC integer;begin DETERMINISTIC:=1; 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 or replace procedure f1 as DIAGNOSTICS integer;begin DIAGNOSTICS:=1; 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 or replace procedure f1 as DIRECTORY integer;begin DIRECTORY:=1; 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 or replace procedure f1 as DISABLE integer;begin DISABLE:=1; 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 or replace procedure f1 as DISCARD integer;begin DISCARD:=1; 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 or replace procedure f1 as DISK integer;begin DISK:=1; 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 or replace procedure f1 as DISTINCT integer;begin DISTINCT:=1; 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 or replace procedure f1 as DISTINCTROW integer;begin DISTINCTROW:=1; 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 or replace procedure f1 as DIV integer;begin DIV:=1; 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 or replace procedure f1 as DO integer;begin DO:=1; 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 or replace procedure f1 as DOUBLE integer;begin DOUBLE:=1; 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 or replace procedure f1 as DO_DOMAIN_IDS integer;begin DO_DOMAIN_IDS:=1; 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 or replace procedure f1 as DROP integer;begin DROP:=1; 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 or replace procedure f1 as DUAL integer;begin DUAL:=1; 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 or replace procedure f1 as DUMPFILE integer;begin DUMPFILE:=1; 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 or replace procedure f1 as DUPLICATE integer;begin DUPLICATE:=1; 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 or replace procedure f1 as DYNAMIC integer;begin DYNAMIC:=1; 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 or replace procedure f1 as EACH integer;begin EACH:=1; 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 or replace procedure f1 as ELSE integer;begin ELSE:=1; 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 or replace procedure f1 as ELSEIF integer;begin ELSEIF:=1; 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 or replace procedure f1 as ELSIF integer;begin ELSIF:=1; 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 or replace procedure f1 as ENABLE integer;begin ENABLE:=1; 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 or replace procedure f1 as ENCLOSED integer;begin ENCLOSED:=1; 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 or replace procedure f1 as END integer;begin END:=1; 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 or replace procedure f1 as ENDS integer;begin ENDS:=1; 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 or replace procedure f1 as ENGINE integer;begin ENGINE:=1; 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 or replace procedure f1 as ENGINES integer;begin ENGINES:=1; 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 or replace procedure f1 as ENUM integer;begin ENUM:=1; 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 or replace procedure f1 as ERROR integer;begin ERROR:=1; 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 or replace procedure f1 as ERRORS integer;begin ERRORS:=1; 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 or replace procedure f1 as ESCAPE integer;begin ESCAPE:=1; 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 or replace procedure f1 as ESCAPED integer;begin ESCAPED:=1; 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 or replace procedure f1 as EVENT integer;begin EVENT:=1; 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 or replace procedure f1 as EVENTS integer;begin EVENTS:=1; 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 or replace procedure f1 as EVERY integer;begin EVERY:=1; 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 or replace procedure f1 as EXAMINED integer;begin EXAMINED:=1; 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 or replace procedure f1 as EXCHANGE integer;begin EXCHANGE:=1; 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 or replace procedure f1 as EXCLUDE integer;begin EXCLUDE:=1; 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 or replace procedure f1 as EXECUTE integer;begin EXECUTE:=1; 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 or replace procedure f1 as EXCEPTION integer;begin EXCEPTION:=1; 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 or replace procedure f1 as EXISTS integer;begin EXISTS:=1; 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 or replace procedure f1 as EXIT integer;begin EXIT:=1; 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 or replace procedure f1 as EXPANSION integer;begin EXPANSION:=1; 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 or replace procedure f1 as EXPORT integer;begin EXPORT:=1; 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 or replace procedure f1 as EXPLAIN integer;begin EXPLAIN:=1; 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 or replace procedure f1 as EXTENDED integer;begin EXTENDED:=1; 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 or replace procedure f1 as EXTENT_SIZE integer;begin EXTENT_SIZE:=1; 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 or replace procedure f1 as FALSE integer;begin FALSE:=1; 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 or replace procedure f1 as FAST integer;begin FAST:=1; 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 or replace procedure f1 as FAULTS integer;begin FAULTS:=1; 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 or replace procedure f1 as FETCH integer;begin FETCH:=1; 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 or replace procedure f1 as FIELDS integer;begin FIELDS:=1; 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 or replace procedure f1 as FILE integer;begin FILE:=1; 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 or replace procedure f1 as FIRST integer;begin FIRST:=1; 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 or replace procedure f1 as FIXED integer;begin FIXED:=1; 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 or replace procedure f1 as FLOAT integer;begin FLOAT:=1; 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 or replace procedure f1 as FLOAT4 integer;begin FLOAT4:=1; 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 or replace procedure f1 as FLOAT8 integer;begin FLOAT8:=1; 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 or replace procedure f1 as FLUSH integer;begin FLUSH:=1; 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 or replace procedure f1 as FOLLOWING integer;begin FOLLOWING:=1; 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 or replace procedure f1 as FOLLOWS integer;begin FOLLOWS:=1; 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 or replace procedure f1 as FOR integer;begin FOR:=1; 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 or replace procedure f1 as FORCE integer;begin FORCE:=1; 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 or replace procedure f1 as FOREIGN integer;begin FOREIGN:=1; 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 or replace procedure f1 as FORMAT integer;begin FORMAT:=1; 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 or replace procedure f1 as FOUND integer;begin FOUND:=1; 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 or replace procedure f1 as FROM integer;begin FROM:=1; 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 or replace procedure f1 as FULL integer;begin FULL:=1; 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 or replace procedure f1 as FULLTEXT integer;begin FULLTEXT:=1; 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 or replace procedure f1 as FUNCTION integer;begin FUNCTION:=1; 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 or replace procedure f1 as GENERAL integer;begin GENERAL:=1; 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 or replace procedure f1 as GENERATED integer;begin GENERATED:=1; 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 or replace procedure f1 as GEOMETRY integer;begin GEOMETRY:=1; 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 or replace procedure f1 as GEOMETRYCOLLECTION integer;begin GEOMETRYCOLLECTION:=1; 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 or replace procedure f1 as GET_FORMAT integer;begin GET_FORMAT:=1; 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 or replace procedure f1 as GET integer;begin GET:=1; 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 or replace procedure f1 as GLOBAL integer;begin GLOBAL:=1; 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 or replace procedure f1 as GOTO integer;begin GOTO:=1; 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 or replace procedure f1 as GRANT integer;begin GRANT:=1; 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 or replace procedure f1 as GRANTS integer;begin GRANTS:=1; 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 or replace procedure f1 as GROUP integer;begin GROUP:=1; 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 or replace procedure f1 as HANDLER integer;begin HANDLER:=1; 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 or replace procedure f1 as HARD integer;begin HARD:=1; 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 or replace procedure f1 as HASH integer;begin HASH:=1; 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 or replace procedure f1 as HAVING integer;begin HAVING:=1; 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 or replace procedure f1 as HELP integer;begin HELP:=1; 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 or replace procedure f1 as HIGH_PRIORITY integer;begin HIGH_PRIORITY:=1; 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 or replace procedure f1 as HOST integer;begin HOST:=1; 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 or replace procedure f1 as HOSTS integer;begin HOSTS:=1; 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 or replace procedure f1 as HOUR integer;begin HOUR:=1; 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 or replace procedure f1 as HOUR_MICROSECOND integer;begin HOUR_MICROSECOND:=1; 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 or replace procedure f1 as HOUR_MINUTE integer;begin HOUR_MINUTE:=1; 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 or replace procedure f1 as HOUR_SECOND integer;begin HOUR_SECOND:=1; 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 or replace procedure f1 as ID integer;begin ID:=1; 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 or replace procedure f1 as IDENTIFIED integer;begin IDENTIFIED:=1; 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 or replace procedure f1 as IF integer;begin IF:=1; 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 or replace procedure f1 as IGNORE integer;begin IGNORE:=1; 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 or replace procedure f1 as IGNORE_DOMAIN_IDS integer;begin IGNORE_DOMAIN_IDS:=1; 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 or replace procedure f1 as IGNORE_SERVER_IDS integer;begin IGNORE_SERVER_IDS:=1; 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 or replace procedure f1 as IMMEDIATE integer;begin IMMEDIATE:=1; 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 or replace procedure f1 as IMPORT integer;begin IMPORT:=1; 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 or replace procedure f1 as IN integer;begin IN:=1; 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 or replace procedure f1 as INDEX integer;begin INDEX:=1; 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 or replace procedure f1 as INDEXES integer;begin INDEXES:=1; 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 or replace procedure f1 as INFILE integer;begin INFILE:=1; 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 or replace procedure f1 as INITIAL_SIZE integer;begin INITIAL_SIZE:=1; 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 or replace procedure f1 as INNER integer;begin INNER:=1; 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 or replace procedure f1 as INOUT integer;begin INOUT:=1; 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 or replace procedure f1 as INSENSITIVE integer;begin INSENSITIVE:=1; 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 or replace procedure f1 as INSERT integer;begin INSERT:=1; 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 or replace procedure f1 as INSERT_METHOD integer;begin INSERT_METHOD:=1; 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 or replace procedure f1 as INSTALL integer;begin INSTALL:=1; 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 or replace procedure f1 as INT integer;begin INT:=1; 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 or replace procedure f1 as INT1 integer;begin INT1:=1; 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 or replace procedure f1 as INT2 integer;begin INT2:=1; 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 or replace procedure f1 as INT3 integer;begin INT3:=1; 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 or replace procedure f1 as INT4 integer;begin INT4:=1; 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 or replace procedure f1 as INT8 integer;begin INT8:=1; 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 or replace procedure f1 as INTEGER integer;begin INTEGER:=1; 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 or replace procedure f1 as INTERVAL integer;begin INTERVAL:=1; 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 or replace procedure f1 as INTO integer;begin INTO:=1; 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 or replace procedure f1 as IO integer;begin IO:=1; 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 or replace procedure f1 as IO_THREAD integer;begin IO_THREAD:=1; 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 or replace procedure f1 as IPC integer;begin IPC:=1; 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 or replace procedure f1 as IS integer;begin IS:=1; 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 or replace procedure f1 as ISOLATION integer;begin ISOLATION:=1; 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 or replace procedure f1 as ISOPEN integer;begin ISOPEN:=1; 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 or replace procedure f1 as ISSUER integer;begin ISSUER:=1; 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 or replace procedure f1 as ITERATE integer;begin ITERATE:=1; 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 or replace procedure f1 as INVOKER integer;begin INVOKER:=1; 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 or replace procedure f1 as JOIN integer;begin JOIN:=1; 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 or replace procedure f1 as JSON integer;begin JSON:=1; 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 or replace procedure f1 as KEY integer;begin KEY:=1; 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 or replace procedure f1 as KEYS integer;begin KEYS:=1; 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 or replace procedure f1 as KEY_BLOCK_SIZE integer;begin KEY_BLOCK_SIZE:=1; 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 or replace procedure f1 as KILL integer;begin KILL:=1; 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 or replace procedure f1 as LANGUAGE integer;begin LANGUAGE:=1; 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 or replace procedure f1 as LAST integer;begin LAST:=1; 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 or replace procedure f1 as LAST_VALUE integer;begin LAST_VALUE:=1; 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 or replace procedure f1 as LEADING integer;begin LEADING:=1; 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 or replace procedure f1 as LEAVE integer;begin LEAVE:=1; 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 or replace procedure f1 as LEAVES integer;begin LEAVES:=1; 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 or replace procedure f1 as LEFT integer;begin LEFT:=1; 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 or replace procedure f1 as LESS integer;begin LESS:=1; 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 or replace procedure f1 as LEVEL integer;begin LEVEL:=1; 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 or replace procedure f1 as LIKE integer;begin LIKE:=1; 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 or replace procedure f1 as LIMIT integer;begin LIMIT:=1; 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 or replace procedure f1 as LINEAR integer;begin LINEAR:=1; 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 or replace procedure f1 as LINES integer;begin LINES:=1; 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 or replace procedure f1 as LINESTRING integer;begin LINESTRING:=1; 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 or replace procedure f1 as LIST integer;begin LIST:=1; 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 or replace procedure f1 as LOAD integer;begin LOAD:=1; 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 or replace procedure f1 as LOCAL integer;begin LOCAL:=1; 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 or replace procedure f1 as LOCALTIME integer;begin LOCALTIME:=1; 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 or replace procedure f1 as LOCALTIMESTAMP integer;begin LOCALTIMESTAMP:=1; 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 or replace procedure f1 as LOCK integer;begin LOCK:=1; 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 or replace procedure f1 as LOCKS integer;begin LOCKS:=1; 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 or replace procedure f1 as LOGFILE integer;begin LOGFILE:=1; 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 or replace procedure f1 as LOGS integer;begin LOGS:=1; 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 or replace procedure f1 as LONG integer;begin LONG:=1; 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 or replace procedure f1 as LONGBLOB integer;begin LONGBLOB:=1; 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 or replace procedure f1 as LONGTEXT integer;begin LONGTEXT:=1; 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 or replace procedure f1 as LOOP integer;begin LOOP:=1; 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 or replace procedure f1 as LOW_PRIORITY integer;begin LOW_PRIORITY:=1; 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 or replace procedure f1 as MASTER integer;begin MASTER:=1; 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 or replace procedure f1 as MASTER_CONNECT_RETRY integer;begin MASTER_CONNECT_RETRY:=1; 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 or replace procedure f1 as MASTER_DELAY integer;begin MASTER_DELAY:=1; 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 or replace procedure f1 as MASTER_GTID_POS integer;begin MASTER_GTID_POS:=1; 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 or replace procedure f1 as MASTER_HOST integer;begin MASTER_HOST:=1; 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 or replace procedure f1 as MASTER_LOG_FILE integer;begin MASTER_LOG_FILE:=1; 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 or replace procedure f1 as MASTER_LOG_POS integer;begin MASTER_LOG_POS:=1; 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 or replace procedure f1 as MASTER_PASSWORD integer;begin MASTER_PASSWORD:=1; 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 or replace procedure f1 as MASTER_PORT integer;begin MASTER_PORT:=1; 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 or replace procedure f1 as MASTER_SERVER_ID integer;begin MASTER_SERVER_ID:=1; 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 or replace procedure f1 as MASTER_SSL integer;begin MASTER_SSL:=1; 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 or replace procedure f1 as MASTER_SSL_CA integer;begin MASTER_SSL_CA:=1; 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 or replace procedure f1 as MASTER_SSL_CAPATH integer;begin MASTER_SSL_CAPATH:=1; 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 or replace procedure f1 as MASTER_SSL_CERT integer;begin MASTER_SSL_CERT:=1; 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 or replace procedure f1 as MASTER_SSL_CIPHER integer;begin MASTER_SSL_CIPHER:=1; 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 or replace procedure f1 as MASTER_SSL_CRL integer;begin MASTER_SSL_CRL:=1; 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 or replace procedure f1 as MASTER_SSL_CRLPATH integer;begin MASTER_SSL_CRLPATH:=1; 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 or replace procedure f1 as MASTER_SSL_KEY integer;begin MASTER_SSL_KEY:=1; 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 or replace procedure f1 as MASTER_SSL_VERIFY_SERVER_CERT integer;begin MASTER_SSL_VERIFY_SERVER_CERT:=1; 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 or replace procedure f1 as MASTER_USER integer;begin MASTER_USER:=1; 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 or replace procedure f1 as MASTER_USE_GTID integer;begin MASTER_USE_GTID:=1; 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 or replace procedure f1 as MASTER_HEARTBEAT_PERIOD integer;begin MASTER_HEARTBEAT_PERIOD:=1; 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 or replace procedure f1 as MATCH integer;begin MATCH:=1; 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 or replace procedure f1 as MAX_CONNECTIONS_PER_HOUR integer;begin MAX_CONNECTIONS_PER_HOUR:=1; 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 or replace procedure f1 as MAX_QUERIES_PER_HOUR integer;begin MAX_QUERIES_PER_HOUR:=1; 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 or replace procedure f1 as MAX_ROWS integer;begin MAX_ROWS:=1; 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 or replace procedure f1 as MAX_SIZE integer;begin MAX_SIZE:=1; 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 or replace procedure f1 as MAX_STATEMENT_TIME integer;begin MAX_STATEMENT_TIME:=1; 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 or replace procedure f1 as MAX_UPDATES_PER_HOUR integer;begin MAX_UPDATES_PER_HOUR:=1; 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 or replace procedure f1 as MAX_USER_CONNECTIONS integer;begin MAX_USER_CONNECTIONS:=1; 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 or replace procedure f1 as MAXVALUE integer;begin MAXVALUE:=1; 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 or replace procedure f1 as MEDIUM integer;begin MEDIUM:=1; 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 or replace procedure f1 as MEDIUMBLOB integer;begin MEDIUMBLOB:=1; 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 or replace procedure f1 as MEDIUMINT integer;begin MEDIUMINT:=1; 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 or replace procedure f1 as MEDIUMTEXT integer;begin MEDIUMTEXT:=1; 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 or replace procedure f1 as MEMORY integer;begin MEMORY:=1; 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 or replace procedure f1 as MERGE integer;begin MERGE:=1; 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 or replace procedure f1 as MESSAGE_TEXT integer;begin MESSAGE_TEXT:=1; 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 or replace procedure f1 as MICROSECOND integer;begin MICROSECOND:=1; 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 or replace procedure f1 as MIDDLEINT integer;begin MIDDLEINT:=1; 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 or replace procedure f1 as MIGRATE integer;begin MIGRATE:=1; 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 or replace procedure f1 as MINUTE integer;begin MINUTE:=1; 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 or replace procedure f1 as MINUTE_MICROSECOND integer;begin MINUTE_MICROSECOND:=1; 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 or replace procedure f1 as MINUTE_SECOND integer;begin MINUTE_SECOND:=1; 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 or replace procedure f1 as MIN_ROWS integer;begin MIN_ROWS:=1; 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 or replace procedure f1 as MOD integer;begin MOD:=1; 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 or replace procedure f1 as MODE integer;begin MODE:=1; 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 or replace procedure f1 as MODIFIES integer;begin MODIFIES:=1; 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 or replace procedure f1 as MODIFY integer;begin MODIFY:=1; 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 or replace procedure f1 as MONTH integer;begin MONTH:=1; 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 or replace procedure f1 as MULTILINESTRING integer;begin MULTILINESTRING:=1; 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 or replace procedure f1 as MULTIPOINT integer;begin MULTIPOINT:=1; 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 or replace procedure f1 as MULTIPOLYGON integer;begin MULTIPOLYGON:=1; 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 or replace procedure f1 as MUTEX integer;begin MUTEX:=1; 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 or replace procedure f1 as MYSQL integer;begin MYSQL:=1; 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 or replace procedure f1 as MYSQL_ERRNO integer;begin MYSQL_ERRNO:=1; 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 or replace procedure f1 as NAME integer;begin NAME:=1; 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 or replace procedure f1 as NAMES integer;begin NAMES:=1; 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 or replace procedure f1 as NATIONAL integer;begin NATIONAL:=1; 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 or replace procedure f1 as NATURAL integer;begin NATURAL:=1; 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 or replace procedure f1 as NCHAR integer;begin NCHAR:=1; 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 or replace procedure f1 as NEW integer;begin NEW:=1; 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 or replace procedure f1 as NEXT integer;begin NEXT:=1; 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 or replace procedure f1 as NO integer;begin NO:=1; 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 or replace procedure f1 as NO_WAIT integer;begin NO_WAIT:=1; 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 or replace procedure f1 as NODEGROUP integer;begin NODEGROUP:=1; 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 or replace procedure f1 as NONE integer;begin NONE:=1; 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 or replace procedure f1 as NOT integer;begin NOT:=1; 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 or replace procedure f1 as NOTFOUND integer;begin NOTFOUND:=1; 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 or replace procedure f1 as NO_WRITE_TO_BINLOG integer;begin NO_WRITE_TO_BINLOG:=1; 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 or replace procedure f1 as NULL integer;begin NULL:=1; 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 or replace procedure f1 as NUMBER integer;begin NUMBER:=1; 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 or replace procedure f1 as NUMERIC integer;begin NUMERIC:=1; 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 or replace procedure f1 as NVARCHAR integer;begin NVARCHAR:=1; 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 or replace procedure f1 as OFFSET integer;begin OFFSET:=1; 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 or replace procedure f1 as OLD_PASSWORD integer;begin OLD_PASSWORD:=1; 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 or replace procedure f1 as ON integer;begin ON:=1; 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 or replace procedure f1 as ONE integer;begin ONE:=1; 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 or replace procedure f1 as ONLINE integer;begin ONLINE:=1; 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 or replace procedure f1 as ONLY integer;begin ONLY:=1; 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 or replace procedure f1 as OPEN integer;begin OPEN:=1; 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 or replace procedure f1 as OPTIMIZE integer;begin OPTIMIZE:=1; 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 or replace procedure f1 as OPTIONS integer;begin OPTIONS:=1; 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 or replace procedure f1 as OPTION integer;begin OPTION:=1; 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 or replace procedure f1 as OPTIONALLY integer;begin OPTIONALLY:=1; 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 or replace procedure f1 as OR integer;begin OR:=1; 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 or replace procedure f1 as ORDER integer;begin ORDER:=1; 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 or replace procedure f1 as OTHERS integer;begin OTHERS:=1; 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 or replace procedure f1 as OUT integer;begin OUT:=1; 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 or replace procedure f1 as OUTER integer;begin OUTER:=1; 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 or replace procedure f1 as OUTFILE integer;begin OUTFILE:=1; 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 or replace procedure f1 as OVER integer;begin OVER:=1; 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 or replace procedure f1 as OWNER integer;begin OWNER:=1; 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 or replace procedure f1 as PACKAGE integer;begin PACKAGE:=1; 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 or replace procedure f1 as PACK_KEYS integer;begin PACK_KEYS:=1; 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 or replace procedure f1 as PAGE integer;begin PAGE:=1; 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 or replace procedure f1 as PAGE_CHECKSUM integer;begin PAGE_CHECKSUM:=1; 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 or replace procedure f1 as PARSER integer;begin PARSER:=1; 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 or replace procedure f1 as PARSE_VCOL_EXPR integer;begin PARSE_VCOL_EXPR:=1; 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 or replace procedure f1 as PARTIAL integer;begin PARTIAL:=1; 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 or replace procedure f1 as PARTITION integer;begin PARTITION:=1; 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 or replace procedure f1 as PARTITIONING integer;begin PARTITIONING:=1; 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 or replace procedure f1 as PARTITIONS integer;begin PARTITIONS:=1; 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 or replace procedure f1 as PASSWORD integer;begin PASSWORD:=1; 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 or replace procedure f1 as PERSISTENT integer;begin PERSISTENT:=1; 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 or replace procedure f1 as PHASE integer;begin PHASE:=1; 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 or replace procedure f1 as PLUGIN integer;begin PLUGIN:=1; 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 or replace procedure f1 as PLUGINS integer;begin PLUGINS:=1; 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 or replace procedure f1 as POINT integer;begin POINT:=1; 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 or replace procedure f1 as POLYGON integer;begin POLYGON:=1; 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 or replace procedure f1 as PORT integer;begin PORT:=1; 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 or replace procedure f1 as PRECEDES integer;begin PRECEDES:=1; 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 or replace procedure f1 as PRECEDING integer;begin PRECEDING:=1; 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 or replace procedure f1 as PRECISION integer;begin PRECISION:=1; 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 or replace procedure f1 as PREPARE integer;begin PREPARE:=1; 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 or replace procedure f1 as PRESERVE integer;begin PRESERVE:=1; 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 or replace procedure f1 as PREV integer;begin PREV:=1; 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 or replace procedure f1 as PRIMARY integer;begin PRIMARY:=1; 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 or replace procedure f1 as PRIVILEGES integer;begin PRIVILEGES:=1; 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 or replace procedure f1 as PROCEDURE integer;begin PROCEDURE:=1; 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 or replace procedure f1 as PROCESS integer;begin PROCESS:=1; 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 or replace procedure f1 as PROCESSLIST integer;begin PROCESSLIST:=1; 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 or replace procedure f1 as PROFILE integer;begin PROFILE:=1; 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 or replace procedure f1 as PROFILES integer;begin PROFILES:=1; 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 or replace procedure f1 as PROXY integer;begin PROXY:=1; 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 or replace procedure f1 as PURGE integer;begin PURGE:=1; 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 or replace procedure f1 as QUARTER integer;begin QUARTER:=1; 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 or replace procedure f1 as QUERY integer;begin QUERY:=1; 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 or replace procedure f1 as QUICK integer;begin QUICK:=1; 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 or replace procedure f1 as RAISE integer;begin RAISE:=1; 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 or replace procedure f1 as RANGE integer;begin RANGE:=1; 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 or replace procedure f1 as RAW integer;begin RAW:=1; 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 or replace procedure f1 as READ integer;begin READ:=1; 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 or replace procedure f1 as READ_ONLY integer;begin READ_ONLY:=1; 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 or replace procedure f1 as READ_WRITE integer;begin READ_WRITE:=1; 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 or replace procedure f1 as READS integer;begin READS:=1; 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 or replace procedure f1 as REAL integer;begin REAL:=1; 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 or replace procedure f1 as REBUILD integer;begin REBUILD:=1; 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 or replace procedure f1 as RECOVER integer;begin RECOVER:=1; 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 or replace procedure f1 as RECURSIVE integer;begin RECURSIVE:=1; 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 or replace procedure f1 as REDO_BUFFER_SIZE integer;begin REDO_BUFFER_SIZE:=1; 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 or replace procedure f1 as REDOFILE integer;begin REDOFILE:=1; 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 or replace procedure f1 as REDUNDANT integer;begin REDUNDANT:=1; 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 or replace procedure f1 as REFERENCES integer;begin REFERENCES:=1; 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 or replace procedure f1 as REGEXP integer;begin REGEXP:=1; 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 or replace procedure f1 as RELAY integer;begin RELAY:=1; 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 or replace procedure f1 as RELAYLOG integer;begin RELAYLOG:=1; 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 or replace procedure f1 as RELAY_LOG_FILE integer;begin RELAY_LOG_FILE:=1; 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 or replace procedure f1 as RELAY_LOG_POS integer;begin RELAY_LOG_POS:=1; 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 or replace procedure f1 as RELAY_THREAD integer;begin RELAY_THREAD:=1; 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 or replace procedure f1 as RELEASE integer;begin RELEASE:=1; 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 or replace procedure f1 as RELOAD integer;begin RELOAD:=1; 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 or replace procedure f1 as REMOVE integer;begin REMOVE:=1; 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 or replace procedure f1 as RENAME integer;begin RENAME:=1; 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 or replace procedure f1 as REORGANIZE integer;begin REORGANIZE:=1; 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 or replace procedure f1 as REPAIR integer;begin REPAIR:=1; 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 or replace procedure f1 as REPEATABLE integer;begin REPEATABLE:=1; 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 or replace procedure f1 as REPLACE integer;begin REPLACE:=1; 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 or replace procedure f1 as REPLICATION integer;begin REPLICATION:=1; 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 or replace procedure f1 as REPEAT integer;begin REPEAT:=1; 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 or replace procedure f1 as REQUIRE integer;begin REQUIRE:=1; 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 or replace procedure f1 as RESET integer;begin RESET:=1; 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 or replace procedure f1 as RESIGNAL integer;begin RESIGNAL:=1; 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 or replace procedure f1 as RESTORE integer;begin RESTORE:=1; 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 or replace procedure f1 as RESTRICT integer;begin RESTRICT:=1; 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 or replace procedure f1 as RESUME integer;begin RESUME:=1; 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 or replace procedure f1 as RETURNED_SQLSTATE integer;begin RETURNED_SQLSTATE:=1; 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 or replace procedure f1 as RETURN integer;begin RETURN:=1; 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 or replace procedure f1 as RETURNING integer;begin RETURNING:=1; 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 or replace procedure f1 as RETURNS integer;begin RETURNS:=1; 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 or replace procedure f1 as REUSE integer;begin REUSE:=1; 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 or replace procedure f1 as REVERSE integer;begin REVERSE:=1; 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 or replace procedure f1 as REVOKE integer;begin REVOKE:=1; 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 or replace procedure f1 as RIGHT integer;begin RIGHT:=1; 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 or replace procedure f1 as RLIKE integer;begin RLIKE:=1; 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 or replace procedure f1 as ROLE integer;begin ROLE:=1; 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 or replace procedure f1 as ROLLBACK integer;begin ROLLBACK:=1; 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 or replace procedure f1 as ROLLUP integer;begin ROLLUP:=1; 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 or replace procedure f1 as ROUTINE integer;begin ROUTINE:=1; 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 or replace procedure f1 as ROW integer;begin ROW:=1; 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 or replace procedure f1 as ROWCOUNT integer;begin ROWCOUNT:=1; 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 or replace procedure f1 as ROWS integer;begin ROWS:=1; 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 or replace procedure f1 as ROW_COUNT integer;begin ROW_COUNT:=1; 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 or replace procedure f1 as ROW_FORMAT integer;begin ROW_FORMAT:=1; 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 or replace procedure f1 as RTREE integer;begin RTREE:=1; 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 or replace procedure f1 as SAVEPOINT integer;begin SAVEPOINT:=1; 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 or replace procedure f1 as SCHEDULE integer;begin SCHEDULE:=1; 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 or replace procedure f1 as SCHEMA integer;begin SCHEMA:=1; 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 or replace procedure f1 as SCHEMA_NAME integer;begin SCHEMA_NAME:=1; 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 or replace procedure f1 as SCHEMAS integer;begin SCHEMAS:=1; 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 or replace procedure f1 as SECOND integer;begin SECOND:=1; 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 or replace procedure f1 as SECOND_MICROSECOND integer;begin SECOND_MICROSECOND:=1; 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 or replace procedure f1 as SECURITY integer;begin SECURITY:=1; 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 or replace procedure f1 as SELECT integer;begin SELECT:=1; 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 or replace procedure f1 as SENSITIVE integer;begin SENSITIVE:=1; 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 or replace procedure f1 as SEPARATOR integer;begin SEPARATOR:=1; 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 or replace procedure f1 as SERIAL integer;begin SERIAL:=1; 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 or replace procedure f1 as SERIALIZABLE integer;begin SERIALIZABLE:=1; 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 or replace procedure f1 as SESSION integer;begin SESSION:=1; 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 or replace procedure f1 as SERVER integer;begin SERVER:=1; 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 or replace procedure f1 as SET integer;begin SET:=1; 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 or replace procedure f1 as SHARE integer;begin SHARE:=1; 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 or replace procedure f1 as SHOW integer;begin SHOW:=1; 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 or replace procedure f1 as SHUTDOWN integer;begin SHUTDOWN:=1; 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 or replace procedure f1 as SIGNAL integer;begin SIGNAL:=1; 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 or replace procedure f1 as SIGNED integer;begin SIGNED:=1; 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 or replace procedure f1 as SIMPLE integer;begin SIMPLE:=1; 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 or replace procedure f1 as SLAVE integer;begin SLAVE:=1; 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 or replace procedure f1 as SLAVES integer;begin SLAVES:=1; 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 or replace procedure f1 as SLAVE_POS integer;begin SLAVE_POS:=1; 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 or replace procedure f1 as SLOW integer;begin SLOW:=1; 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 or replace procedure f1 as SNAPSHOT integer;begin SNAPSHOT:=1; 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 or replace procedure f1 as SMALLINT integer;begin SMALLINT:=1; 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 or replace procedure f1 as SOCKET integer;begin SOCKET:=1; 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 or replace procedure f1 as SOFT integer;begin SOFT:=1; 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 or replace procedure f1 as SOME integer;begin SOME:=1; 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 or replace procedure f1 as SONAME integer;begin SONAME:=1; 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 or replace procedure f1 as SOUNDS integer;begin SOUNDS:=1; 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 or replace procedure f1 as SOURCE integer;begin SOURCE:=1; 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 or replace procedure f1 as STORED integer;begin STORED:=1; 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 or replace procedure f1 as SPATIAL integer;begin SPATIAL:=1; 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 or replace procedure f1 as SPECIFIC integer;begin SPECIFIC:=1; 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 or replace procedure f1 as REF_SYSTEM_ID integer;begin REF_SYSTEM_ID:=1; 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 or replace procedure f1 as SQL integer;begin SQL:=1; 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 or replace procedure f1 as SQLEXCEPTION integer;begin SQLEXCEPTION:=1; 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 or replace procedure f1 as SQLSTATE integer;begin SQLSTATE:=1; 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 or replace procedure f1 as SQLWARNING integer;begin SQLWARNING:=1; 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 or replace procedure f1 as SQL_BIG_RESULT integer;begin SQL_BIG_RESULT:=1; 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 or replace procedure f1 as SQL_BUFFER_RESULT integer;begin SQL_BUFFER_RESULT:=1; 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 or replace procedure f1 as SQL_CACHE integer;begin SQL_CACHE:=1; 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 or replace procedure f1 as SQL_CALC_FOUND_ROWS integer;begin SQL_CALC_FOUND_ROWS:=1; 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 or replace procedure f1 as SQL_NO_CACHE integer;begin SQL_NO_CACHE:=1; 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 or replace procedure f1 as SQL_SMALL_RESULT integer;begin SQL_SMALL_RESULT:=1; 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 or replace procedure f1 as SQL_THREAD integer;begin SQL_THREAD:=1; 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 or replace procedure f1 as SQL_TSI_SECOND integer;begin SQL_TSI_SECOND:=1; 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 or replace procedure f1 as SQL_TSI_MINUTE integer;begin SQL_TSI_MINUTE:=1; 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 or replace procedure f1 as SQL_TSI_HOUR integer;begin SQL_TSI_HOUR:=1; 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 or replace procedure f1 as SQL_TSI_DAY integer;begin SQL_TSI_DAY:=1; 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 or replace procedure f1 as SQL_TSI_WEEK integer;begin SQL_TSI_WEEK:=1; 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 or replace procedure f1 as SQL_TSI_MONTH integer;begin SQL_TSI_MONTH:=1; 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 or replace procedure f1 as SQL_TSI_QUARTER integer;begin SQL_TSI_QUARTER:=1; 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 or replace procedure f1 as SQL_TSI_YEAR integer;begin SQL_TSI_YEAR:=1; 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 or replace procedure f1 as SSL integer;begin SSL:=1; 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 or replace procedure f1 as START integer;begin START:=1; 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 or replace procedure f1 as STARTING integer;begin STARTING:=1; 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 or replace procedure f1 as STARTS integer;begin STARTS:=1; 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 or replace procedure f1 as STATEMENT integer;begin STATEMENT:=1; 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 or replace procedure f1 as STATS_AUTO_RECALC integer;begin STATS_AUTO_RECALC:=1; 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 or replace procedure f1 as STATS_PERSISTENT integer;begin STATS_PERSISTENT:=1; 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 or replace procedure f1 as STATS_SAMPLE_PAGES integer;begin STATS_SAMPLE_PAGES:=1; 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 or replace procedure f1 as STATUS integer;begin STATUS:=1; 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 or replace procedure f1 as STOP integer;begin STOP:=1; 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 or replace procedure f1 as STORAGE integer;begin STORAGE:=1; 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 or replace procedure f1 as STRAIGHT_JOIN integer;begin STRAIGHT_JOIN:=1; 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 or replace procedure f1 as STRING integer;begin STRING:=1; 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 or replace procedure f1 as SUBCLASS_ORIGIN integer;begin SUBCLASS_ORIGIN:=1; 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 or replace procedure f1 as SUBJECT integer;begin SUBJECT:=1; 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 or replace procedure f1 as SUBPARTITION integer;begin SUBPARTITION:=1; 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 or replace procedure f1 as SUBPARTITIONS integer;begin SUBPARTITIONS:=1; 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 or replace procedure f1 as SUPER integer;begin SUPER:=1; 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 or replace procedure f1 as SUSPEND integer;begin SUSPEND:=1; 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 or replace procedure f1 as SWAPS integer;begin SWAPS:=1; 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 or replace procedure f1 as SWITCHES integer;begin SWITCHES:=1; 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 or replace procedure f1 as TABLE integer;begin TABLE:=1; 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 or replace procedure f1 as TABLE_NAME integer;begin TABLE_NAME:=1; 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 or replace procedure f1 as TABLES integer;begin TABLES:=1; 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 or replace procedure f1 as TABLESPACE integer;begin TABLESPACE:=1; 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 or replace procedure f1 as TABLE_CHECKSUM integer;begin TABLE_CHECKSUM:=1; 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 or replace procedure f1 as TEMPORARY integer;begin TEMPORARY:=1; 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 or replace procedure f1 as TEMPTABLE integer;begin TEMPTABLE:=1; 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 or replace procedure f1 as TERMINATED integer;begin TERMINATED:=1; 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 or replace procedure f1 as TEXT integer;begin TEXT:=1; 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 or replace procedure f1 as THAN integer;begin THAN:=1; 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 or replace procedure f1 as THEN integer;begin THEN:=1; 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 or replace procedure f1 as TIES integer;begin TIES:=1; 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 or replace procedure f1 as TIME integer;begin TIME:=1; 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 or replace procedure f1 as TIMESTAMP integer;begin TIMESTAMP:=1; 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 or replace procedure f1 as TIMESTAMPADD integer;begin TIMESTAMPADD:=1; 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 or replace procedure f1 as TIMESTAMPDIFF integer;begin TIMESTAMPDIFF:=1; 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 or replace procedure f1 as TINYBLOB integer;begin TINYBLOB:=1; 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 or replace procedure f1 as TINYINT integer;begin TINYINT:=1; 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 or replace procedure f1 as TINYTEXT integer;begin TINYTEXT:=1; 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 or replace procedure f1 as TO integer;begin TO:=1; 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 or replace procedure f1 as TRAILING integer;begin TRAILING:=1; 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 or replace procedure f1 as TRANSACTION integer;begin TRANSACTION:=1; 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 or replace procedure f1 as TRANSACTIONAL integer;begin TRANSACTIONAL:=1; 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 or replace procedure f1 as TRIGGER integer;begin TRIGGER:=1; 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 or replace procedure f1 as TRIGGERS integer;begin TRIGGERS:=1; 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 or replace procedure f1 as TRUE integer;begin TRUE:=1; 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 or replace procedure f1 as TRUNCATE integer;begin TRUNCATE:=1; 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 or replace procedure f1 as TYPE integer;begin TYPE:=1; 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 or replace procedure f1 as TYPES integer;begin TYPES:=1; 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 or replace procedure f1 as UNBOUNDED integer;begin UNBOUNDED:=1; 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 or replace procedure f1 as UNCOMMITTED integer;begin UNCOMMITTED:=1; 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 or replace procedure f1 as UNDEFINED integer;begin UNDEFINED:=1; 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 or replace procedure f1 as UNDO_BUFFER_SIZE integer;begin UNDO_BUFFER_SIZE:=1; 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 or replace procedure f1 as UNDOFILE integer;begin UNDOFILE:=1; 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 or replace procedure f1 as UNDO integer;begin UNDO:=1; 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 or replace procedure f1 as UNICODE integer;begin UNICODE:=1; 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 or replace procedure f1 as UNION integer;begin UNION:=1; 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 or replace procedure f1 as UNIQUE integer;begin UNIQUE:=1; 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 or replace procedure f1 as UNKNOWN integer;begin UNKNOWN:=1; 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 or replace procedure f1 as UNLOCK integer;begin UNLOCK:=1; 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 or replace procedure f1 as UNINSTALL integer;begin UNINSTALL:=1; 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 or replace procedure f1 as UNSIGNED integer;begin UNSIGNED:=1; 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 or replace procedure f1 as UNTIL integer;begin UNTIL:=1; 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 or replace procedure f1 as UPDATE integer;begin UPDATE:=1; 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 or replace procedure f1 as UPGRADE integer;begin UPGRADE:=1; 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 or replace procedure f1 as USAGE integer;begin USAGE:=1; 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 or replace procedure f1 as USE integer;begin USE:=1; 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 or replace procedure f1 as USER integer;begin USER:=1; 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 or replace procedure f1 as USER_RESOURCES integer;begin USER_RESOURCES:=1; 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 or replace procedure f1 as USE_FRM integer;begin USE_FRM:=1; 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 or replace procedure f1 as USING integer;begin USING:=1; 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 or replace procedure f1 as UTC_DATE integer;begin UTC_DATE:=1; 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 or replace procedure f1 as UTC_TIME integer;begin UTC_TIME:=1; 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 or replace procedure f1 as UTC_TIMESTAMP integer;begin UTC_TIMESTAMP:=1; 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 or replace procedure f1 as VALUE integer;begin VALUE:=1; 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 or replace procedure f1 as VALUES integer;begin VALUES:=1; 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 or replace procedure f1 as VARBINARY integer;begin VARBINARY:=1; 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 or replace procedure f1 as VARCHAR integer;begin VARCHAR:=1; 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 or replace procedure f1 as VARCHARACTER integer;begin VARCHARACTER:=1; 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 or replace procedure f1 as VARCHAR2 integer;begin VARCHAR2:=1; 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 or replace procedure f1 as VARIABLES integer;begin VARIABLES:=1; 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 or replace procedure f1 as VARYING integer;begin VARYING:=1; 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 or replace procedure f1 as VIA integer;begin VIA:=1; 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 or replace procedure f1 as VIEW integer;begin VIEW:=1; 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 or replace procedure f1 as VIRTUAL integer;begin VIRTUAL:=1; 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 or replace procedure f1 as WAIT integer;begin WAIT:=1; 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 or replace procedure f1 as WARNINGS integer;begin WARNINGS:=1; 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 or replace procedure f1 as WEEK integer;begin WEEK:=1; 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 or replace procedure f1 as WEIGHT_STRING integer;begin WEIGHT_STRING:=1; 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 or replace procedure f1 as WHEN integer;begin WHEN:=1; 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 or replace procedure f1 as WHERE integer;begin WHERE:=1; 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 or replace procedure f1 as WHILE integer;begin WHILE:=1; 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 or replace procedure f1 as WINDOW integer;begin WINDOW:=1; 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 or replace procedure f1 as WITH integer;begin WITH:=1; 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 or replace procedure f1 as WORK integer;begin WORK:=1; 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 or replace procedure f1 as WRAPPER integer;begin WRAPPER:=1; 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 or replace procedure f1 as WRITE integer;begin WRITE:=1; 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 or replace procedure f1 as X509 integer;begin X509:=1; 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 or replace procedure f1 as XOR integer;begin XOR:=1; 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 or replace procedure f1 as XA integer;begin XA:=1; 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 or replace procedure f1 as XML integer;begin XML:=1; 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 or replace procedure f1 as YEAR integer;begin YEAR:=1; 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 or replace procedure f1 as YEAR_MONTH integer;begin YEAR_MONTH:=1; 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 or replace procedure f1 as ZEROFILL integer;begin ZEROFILL:=1; 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 or replace procedure f1 as ADDDATE integer;begin ADDDATE:=1; 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 or replace procedure f1 as BIT_AND integer;begin BIT_AND:=1; 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 or replace procedure f1 as BIT_OR integer;begin BIT_OR:=1; 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 or replace procedure f1 as BIT_XOR integer;begin BIT_XOR:=1; 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 or replace procedure f1 as CAST integer;begin CAST:=1; 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 or replace procedure f1 as COUNT integer;begin COUNT:=1; 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 or replace procedure f1 as CUME_DIST integer;begin CUME_DIST:=1; 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 or replace procedure f1 as CURDATE integer;begin CURDATE:=1; 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 or replace procedure f1 as CURTIME integer;begin CURTIME:=1; 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 or replace procedure f1 as DATE_ADD integer;begin DATE_ADD:=1; 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 or replace procedure f1 as DATE_SUB integer;begin DATE_SUB:=1; 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 or replace procedure f1 as DECODE integer;begin DECODE:=1; 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 or replace procedure f1 as DENSE_RANK integer;begin DENSE_RANK:=1; 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 or replace procedure f1 as EXTRACT integer;begin EXTRACT:=1; 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 or replace procedure f1 as FIRST_VALUE integer;begin FIRST_VALUE:=1; 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 or replace procedure f1 as GROUP_CONCAT integer;begin GROUP_CONCAT:=1; 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 or replace procedure f1 as LAG integer;begin LAG:=1; 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 or replace procedure f1 as LEAD integer;begin LEAD:=1; 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 or replace procedure f1 as MAX integer;begin MAX:=1; 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 or replace procedure f1 as MID integer;begin MID:=1; 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 or replace procedure f1 as MIN integer;begin MIN:=1; 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 or replace procedure f1 as NOW integer;begin NOW:=1; 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 or replace procedure f1 as NTH_VALUE integer;begin NTH_VALUE:=1; 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 or replace procedure f1 as NTILE integer;begin NTILE:=1; 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 or replace procedure f1 as POSITION integer;begin POSITION:=1; 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 or replace procedure f1 as PERCENT_RANK integer;begin PERCENT_RANK:=1; 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 or replace procedure f1 as RANK integer;begin RANK:=1; 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 or replace procedure f1 as ROW_NUMBER integer;begin ROW_NUMBER:=1; 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 or replace procedure f1 as SESSION_USER integer;begin SESSION_USER:=1; 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 or replace procedure f1 as STD integer;begin STD:=1; 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 or replace procedure f1 as STDDEV integer;begin STDDEV:=1; 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 or replace procedure f1 as STDDEV_POP integer;begin STDDEV_POP:=1; 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 or replace procedure f1 as STDDEV_SAMP integer;begin STDDEV_SAMP:=1; 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 or replace procedure f1 as SUBDATE integer;begin SUBDATE:=1; 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 or replace procedure f1 as SUBSTR integer;begin SUBSTR:=1; 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 or replace procedure f1 as SUBSTRING integer;begin SUBSTRING:=1; 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 or replace procedure f1 as SUM integer;begin SUM:=1; 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 or replace procedure f1 as SYSDATE integer;begin SYSDATE:=1; 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 or replace procedure f1 as SYSTEM_USER integer;begin SYSTEM_USER:=1; 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 or replace procedure f1 as TRIM integer;begin TRIM:=1; 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 or replace procedure f1 as VARIANCE integer;begin VARIANCE:=1; 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 or replace procedure f1 as VAR_POP integer;begin VAR_POP:=1; 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 or replace procedure f1 as VAR_SAMP integer;begin VAR_SAMP:=1; 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;
