create function pg_catalog.pg_isolation_test_session_is_blocked(integer, integer[]) returns boolean
  language internal;

-- Is JIT compilation available in this session?
create function pg_catalog.pg_jit_available() returns boolean
  language internal;

-- get transaction Id, commit timestamp and replication origin of latest transaction commit
create function pg_catalog.pg_last_committed_xact(OUT xid xid, OUT "timestamp" timestamp with time zone, OUT roident oid) returns record
  language internal;

-- current wal flush location
create function pg_catalog.pg_last_wal_receive_lsn() returns pg_lsn
  language internal;

-- last wal replay location
create function pg_catalog.pg_last_wal_replay_lsn() returns pg_lsn
  language internal;

-- timestamp of last replay xact
create function pg_catalog.pg_last_xact_replay_timestamp() returns timestamp with time zone
  language internal;

-- get the channels that the current backend listens to
create function pg_catalog.pg_listening_channels() returns SETOF text
  language internal;

-- view system lock information
create function pg_catalog.pg_lock_status(OUT locktype text, OUT database oid, OUT relation oid, OUT page integer, OUT tuple smallint, OUT virtualxid text, OUT transactionid xid, OUT classid oid, OUT objid oid, OUT objsubid smallint, OUT virtualtransaction text, OUT pid integer, OUT mode text, OUT granted boolean, OUT fastpath boolean, OUT waitstart timestamp with time zone) returns SETOF record
  language internal;

-- log memory contexts of the specified backend
create function pg_catalog.pg_log_backend_memory_contexts(integer) returns boolean
  language internal;

-- log details of the current snapshot to WAL
create function pg_catalog.pg_log_standby_snapshot() returns pg_lsn
  language internal;

-- emit a binary logical decoding message
create function pg_catalog.pg_logical_emit_message(transactional boolean, prefix text, message bytea, flush boolean DEFAULT false) returns pg_lsn
  language internal;

-- emit a textual logical decoding message
create function pg_catalog.pg_logical_emit_message(transactional boolean, prefix text, message text, flush boolean DEFAULT false) returns pg_lsn
  language internal;

-- get binary changes from replication slot
create function pg_catalog.pg_logical_slot_get_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, VARIADIC options text[] DEFAULT '{}'::text[], OUT lsn pg_lsn, OUT xid xid, OUT data bytea) returns SETOF record
  language internal;

-- get changes from replication slot
create function pg_catalog.pg_logical_slot_get_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, VARIADIC options text[] DEFAULT '{}'::text[], OUT lsn pg_lsn, OUT xid xid, OUT data text) returns SETOF record
  language internal;

-- peek at binary changes from replication slot
create function pg_catalog.pg_logical_slot_peek_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, VARIADIC options text[] DEFAULT '{}'::text[], OUT lsn pg_lsn, OUT xid xid, OUT data bytea) returns SETOF record
  language internal;

-- peek at changes from replication slot
create function pg_catalog.pg_logical_slot_peek_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, VARIADIC options text[] DEFAULT '{}'::text[], OUT lsn pg_lsn, OUT xid xid, OUT data text) returns SETOF record
  language internal;

-- list of files in the archive_status directory
create function pg_catalog.pg_ls_archive_statusdir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list all files in a directory
create function pg_catalog.pg_ls_dir(text) returns SETOF text
  language internal;

-- list all files in a directory
create function pg_catalog.pg_ls_dir(text, boolean, boolean) returns SETOF text
  language internal;

-- list files in the log directory
create function pg_catalog.pg_ls_logdir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list of files in the pg_logical/mappings directory
create function pg_catalog.pg_ls_logicalmapdir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list of files in the pg_logical/snapshots directory
create function pg_catalog.pg_ls_logicalsnapdir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list of files in the pg_replslot/slot_name directory
create function pg_catalog.pg_ls_replslotdir(slot_name text, OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list of files in the pg_wal/summaries directory
create function pg_catalog.pg_ls_summariesdir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list files in the pgsql_tmp directory
create function pg_catalog.pg_ls_tmpdir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list files in the pgsql_tmp directory
create function pg_catalog.pg_ls_tmpdir(tablespace oid, OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- list of files in the WAL directory
create function pg_catalog.pg_ls_waldir(OUT name text, OUT size bigint, OUT modification timestamp with time zone) returns SETOF record
  language internal;

-- convert numeric to pg_lsn
create function pg_catalog.pg_lsn(numeric) returns pg_lsn
  language internal;

-- less-equal-greater
create function pg_catalog.pg_lsn_cmp(pg_lsn, pg_lsn) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.pg_lsn_eq(pg_lsn, pg_lsn) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.pg_lsn_ge(pg_lsn, pg_lsn) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.pg_lsn_gt(pg_lsn, pg_lsn) returns boolean
  language internal;

-- hash
create function pg_catalog.pg_lsn_hash(pg_lsn) returns integer
  language internal;

-- hash
create function pg_catalog.pg_lsn_hash_extended(pg_lsn, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.pg_lsn_in(cstring) returns pg_lsn
  language internal;

-- larger of two
create function pg_catalog.pg_lsn_larger(pg_lsn, pg_lsn) returns pg_lsn
  language internal;

-- implementation of <= operator
create function pg_catalog.pg_lsn_le(pg_lsn, pg_lsn) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.pg_lsn_lt(pg_lsn, pg_lsn) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.pg_lsn_mi(pg_lsn, pg_lsn) returns numeric
  language internal;

-- implementation of - operator
create function pg_catalog.pg_lsn_mii(pg_lsn, numeric) returns pg_lsn
  language internal;

-- implementation of <> operator
create function pg_catalog.pg_lsn_ne(pg_lsn, pg_lsn) returns boolean
  language internal;

-- I/O
create function pg_catalog.pg_lsn_out(pg_lsn) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.pg_lsn_pli(pg_lsn, numeric) returns pg_lsn
  language internal;

-- I/O
create function pg_catalog.pg_lsn_recv(internal) returns pg_lsn
  language internal;

-- I/O
create function pg_catalog.pg_lsn_send(pg_lsn) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.pg_lsn_smaller(pg_lsn, pg_lsn) returns pg_lsn
  language internal;

-- I/O
create function pg_catalog.pg_mcv_list_in(cstring) returns pg_mcv_list
  language internal;

-- details about MCV list items
create function pg_catalog.pg_mcv_list_items(mcv_list pg_mcv_list, OUT index integer, OUT "values" text[], OUT nulls boolean[], OUT frequency double precision, OUT base_frequency double precision) returns SETOF record
  language internal;

-- I/O
create function pg_catalog.pg_mcv_list_out(pg_mcv_list) returns cstring
  language internal;

-- I/O
create function pg_catalog.pg_mcv_list_recv(internal) returns pg_mcv_list
  language internal;

-- I/O
create function pg_catalog.pg_mcv_list_send(pg_mcv_list) returns bytea
  language internal;

-- get OID of current session's temp schema, if any
create function pg_catalog.pg_my_temp_schema() returns oid
  language internal;

-- I/O
create function pg_catalog.pg_ndistinct_in(cstring) returns pg_ndistinct
  language internal;

-- I/O
create function pg_catalog.pg_ndistinct_out(pg_ndistinct) returns cstring
  language internal;

-- I/O
create function pg_catalog.pg_ndistinct_recv(internal) returns pg_ndistinct
  language internal;

-- I/O
create function pg_catalog.pg_ndistinct_send(pg_ndistinct) returns bytea
  language internal;

-- return the next oid for a system table
create function pg_catalog.pg_nextoid(regclass, name, regclass) returns oid
  language internal;

-- I/O
create function pg_catalog.pg_node_tree_in(cstring) returns pg_node_tree
  language internal;

-- I/O
create function pg_catalog.pg_node_tree_out(pg_node_tree) returns cstring
  language internal;

-- I/O
create function pg_catalog.pg_node_tree_recv(internal) returns pg_node_tree
  language internal;

-- I/O
create function pg_catalog.pg_node_tree_send(pg_node_tree) returns bytea
  language internal;

-- get the fraction of the asynchronous notification queue currently in use
create function pg_catalog.pg_notification_queue_usage() returns double precision
  language internal;

-- send a notification event
create function pg_catalog.pg_notify(text, text) returns void
  language internal;

-- Is NUMA support available?
create function pg_catalog.pg_numa_available() returns boolean
  language internal;

-- is opclass visible in search path?
create function pg_catalog.pg_opclass_is_visible(oid) returns boolean
  language internal;

-- is operator visible in search path?
create function pg_catalog.pg_operator_is_visible(oid) returns boolean
  language internal;

-- is opfamily visible in search path?
create function pg_catalog.pg_opfamily_is_visible(oid) returns boolean
  language internal;

-- convert generic options array to name/value table
create function pg_catalog.pg_options_to_table(options_array text[], OUT option_name text, OUT option_value text) returns SETOF record
  language internal;

-- view ancestors of the partition
create function pg_catalog.pg_partition_ancestors(partitionid regclass, OUT relid regclass) returns SETOF regclass
  language internal;

-- get top-most partition root parent
create function pg_catalog.pg_partition_root(regclass) returns regclass
  language internal;

-- view partition tree tables
create function pg_catalog.pg_partition_tree(rootrelid regclass, OUT relid regclass, OUT parentrelid regclass, OUT isleaf boolean, OUT level integer) returns SETOF record
  language internal;

-- postmaster start time
create function pg_catalog.pg_postmaster_start_time() returns timestamp with time zone
  language internal;

-- get the prepared statements for this session
create function pg_catalog.pg_prepared_statement(OUT name text, OUT statement text, OUT prepare_time timestamp with time zone, OUT parameter_types regtype[], OUT result_types regtype[], OUT from_sql boolean, OUT generic_plans bigint, OUT custom_plans bigint) returns SETOF record
  language internal;

-- view two-phase transactions
create function pg_catalog.pg_prepared_xact(OUT transaction xid, OUT gid text, OUT prepared timestamp with time zone, OUT ownerid oid, OUT dbid oid) returns SETOF record
  language internal;

-- promote standby server
create function pg_catalog.pg_promote(wait boolean DEFAULT true, wait_seconds integer DEFAULT 60) returns boolean
  language internal;

-- read bytea from a file
create function pg_catalog.pg_read_binary_file(text) returns bytea
  language internal;

-- read bytea from a file
create function pg_catalog.pg_read_binary_file(text, bigint, bigint) returns bytea
  language internal;

-- read bytea from a file
create function pg_catalog.pg_read_binary_file(text, bigint, bigint, boolean) returns bytea
  language internal;

-- read bytea from a file
create function pg_catalog.pg_read_binary_file(text, boolean) returns bytea
  language internal;

-- read text from a file
create function pg_catalog.pg_read_file(text) returns text
  language internal;

-- read text from a file
create function pg_catalog.pg_read_file(text, bigint, bigint) returns text
  language internal;

-- read text from a file
create function pg_catalog.pg_read_file(text, bigint, bigint, boolean) returns text
  language internal;

-- read text from a file
create function pg_catalog.pg_read_file(text, boolean) returns text
  language internal;

-- filenode identifier of relation
create function pg_catalog.pg_relation_filenode(regclass) returns oid
  language internal;

-- file path of relation
create function pg_catalog.pg_relation_filepath(regclass) returns text
  language internal;

-- returns whether a relation can be part of a publication
create function pg_catalog.pg_relation_is_publishable(regclass) returns boolean
  language internal;

-- is a relation insertable/updatable/deletable
create function pg_catalog.pg_relation_is_updatable(regclass, boolean) returns integer
  language internal;

-- disk space usage for the main fork of the specified table or index
create function pg_catalog.pg_relation_size(regclass) returns bigint
  language sql;

-- disk space usage for the specified fork of a table or index
create function pg_catalog.pg_relation_size(regclass, text) returns bigint
  language internal;

-- reload configuration files
create function pg_catalog.pg_reload_conf() returns boolean
  language internal;

-- advance replication origin to specific location
create function pg_catalog.pg_replication_origin_advance(text, pg_lsn) returns void
  language internal;

-- create a replication origin
create function pg_catalog.pg_replication_origin_create(text) returns oid
  language internal;



-- translate the replication origin's name to its id
create function pg_catalog.pg_replication_origin_oid(text) returns oid
  language internal;

-- get an individual replication origin's replication progress
create function pg_catalog.pg_replication_origin_progress(text, boolean) returns pg_lsn
  language internal;

-- is a replication origin configured in this session
create function pg_catalog.pg_replication_origin_session_is_setup() returns boolean
  language internal;

-- get the replication progress of the current session
create function pg_catalog.pg_replication_origin_session_progress(boolean) returns pg_lsn
  language internal;

-- teardown configured replication progress tracking
create function pg_catalog.pg_replication_origin_session_reset() returns void
  language internal;

-- configure session to maintain replication progress tracking for the passed in origin
create function pg_catalog.pg_replication_origin_session_setup(text) returns void
  language internal;

-- reset the transaction's origin lsn and timestamp
create function pg_catalog.pg_replication_origin_xact_reset() returns void
  language internal;

-- setup the transaction's origin lsn and timestamp
create function pg_catalog.pg_replication_origin_xact_setup(pg_lsn, timestamp with time zone) returns void
  language internal;

-- advance logical replication slot
create function pg_catalog.pg_replication_slot_advance(slot_name name, upto_lsn pg_lsn, OUT slot_name name, OUT end_lsn pg_lsn) returns record
  language internal;

-- restore statistics on attribute
create function pg_catalog.pg_restore_attribute_stats(VARIADIC kwargs "any") returns boolean
  language internal;

-- restore statistics on relation
create function pg_catalog.pg_restore_relation_stats(VARIADIC kwargs "any") returns boolean
  language internal;

-- rotate log file
create function pg_catalog.pg_rotate_logfile() returns boolean
  language internal;

-- get array of PIDs of sessions blocking specified backend PID from acquiring a safe snapshot
create function pg_catalog.pg_safe_snapshot_blocking_pids(integer) returns integer[]
  language internal;

-- sequence last value
create function pg_catalog.pg_sequence_last_value(regclass) returns bigint
  language internal;

-- sequence parameters, for use by information schema
create function pg_catalog.pg_sequence_parameters(sequence_oid oid, OUT start_value bigint, OUT minimum_value bigint, OUT maximum_value bigint, OUT increment bigint, OUT cycle_option boolean, OUT cache_size bigint, OUT data_type oid) returns record
  language internal;

-- return flags for specified GUC
create function pg_catalog.pg_settings_get_flags(text) returns text[]
  language internal;

-- show config file settings
create function pg_catalog.pg_show_all_file_settings(OUT sourcefile text, OUT sourceline integer, OUT seqno integer, OUT name text, OUT setting text, OUT applied boolean, OUT error text) returns SETOF record
  language internal;

-- SHOW ALL as a function
create function pg_catalog.pg_show_all_settings(OUT name text, OUT setting text, OUT unit text, OUT category text, OUT short_desc text, OUT extra_desc text, OUT context text, OUT vartype text, OUT source text, OUT min_val text, OUT max_val text, OUT enumvals text[], OUT boot_val text, OUT reset_val text, OUT sourcefile text, OUT sourceline integer, OUT pending_restart boolean) returns SETOF record
  language internal;

-- get progress for all replication origins
create function pg_catalog.pg_show_replication_origin_status(OUT local_id oid, OUT external_id text, OUT remote_lsn pg_lsn, OUT local_lsn pg_lsn) returns SETOF record
  language internal;

-- convert a size in human-readable format with size units into bytes
create function pg_catalog.pg_size_bytes(text) returns bigint
  language internal;

-- convert a long int to a human readable text using size units
create function pg_catalog.pg_size_pretty(bigint) returns text
  language internal;

-- convert a numeric to a human readable text using size units
create function pg_catalog.pg_size_pretty(numeric) returns text
  language internal;

-- sleep for the specified time in seconds
create function pg_catalog.pg_sleep(double precision) returns void
  language internal;

-- sleep for the specified interval
create function pg_catalog.pg_sleep_for(interval) returns void
  language sql;

-- sleep until the specified time
create function pg_catalog.pg_sleep_until(timestamp with time zone) returns void
  language sql;

-- I/O
create function pg_catalog.pg_snapshot_in(cstring) returns pg_snapshot
  language internal;

-- I/O
create function pg_catalog.pg_snapshot_out(pg_snapshot) returns cstring
  language internal;

-- I/O
create function pg_catalog.pg_snapshot_recv(internal) returns pg_snapshot
  language internal;

-- I/O
create function pg_catalog.pg_snapshot_send(pg_snapshot) returns bytea
  language internal;

-- get set of in-progress transactions in snapshot
create function pg_catalog.pg_snapshot_xip(pg_snapshot) returns SETOF xid8
  language internal;

-- get xmax of snapshot
create function pg_catalog.pg_snapshot_xmax(pg_snapshot) returns xid8
  language internal;

-- get xmin of snapshot
create function pg_catalog.pg_snapshot_xmin(pg_snapshot) returns xid8
  language internal;

-- sequence number and timeline ID given a wal filename
create function pg_catalog.pg_split_walfile_name(file_name text, OUT segment_number numeric, OUT timeline_id bigint) returns record
  language internal;

-- statistics: discard current transaction's statistics snapshot
create function pg_catalog.pg_stat_clear_snapshot() returns void
  language internal;

-- get information about file
create function pg_catalog.pg_stat_file(filename text, missing_ok boolean, OUT size bigint, OUT access timestamp with time zone, OUT modification timestamp with time zone, OUT change timestamp with time zone, OUT creation timestamp with time zone, OUT isdir boolean) returns record
  language internal;

-- get information about file
create function pg_catalog.pg_stat_file(filename text, OUT size bigint, OUT access timestamp with time zone, OUT modification timestamp with time zone, OUT change timestamp with time zone, OUT creation timestamp with time zone, OUT isdir boolean) returns record
  language internal;

-- statistics: force stats to be flushed after the next commit
create function pg_catalog.pg_stat_force_next_flush() returns void
  language internal;

-- statistics: information about currently active backends
create function pg_catalog.pg_stat_get_activity(pid integer, OUT datid oid, OUT pid integer, OUT usesysid oid, OUT application_name text, OUT state text, OUT query text, OUT wait_event_type text, OUT wait_event text, OUT xact_start timestamp with time zone, OUT query_start timestamp with time zone, OUT backend_start timestamp with time zone, OUT state_change timestamp with time zone, OUT client_addr inet, OUT client_hostname text, OUT client_port integer, OUT backend_xid xid, OUT backend_xmin xid, OUT backend_type text, OUT ssl boolean, OUT sslversion text, OUT sslcipher text, OUT sslbits integer, OUT ssl_client_dn text, OUT ssl_client_serial numeric, OUT ssl_issuer_dn text, OUT gss_auth boolean, OUT gss_princ text, OUT gss_enc boolean, OUT gss_delegation boolean, OUT leader_pid integer, OUT query_id bigint) returns SETOF record
  language internal;

-- statistics: number of manual analyzes for a table
create function pg_catalog.pg_stat_get_analyze_count(oid) returns bigint
  language internal;

-- statistics: information about WAL archiver
create function pg_catalog.pg_stat_get_archiver(OUT archived_count bigint, OUT last_archived_wal text, OUT last_archived_time timestamp with time zone, OUT failed_count bigint, OUT last_failed_wal text, OUT last_failed_time timestamp with time zone, OUT stats_reset timestamp with time zone) returns record
  language internal;

-- statistics: number of auto analyzes for a table
create function pg_catalog.pg_stat_get_autoanalyze_count(oid) returns bigint
  language internal;

-- statistics: number of auto vacuums for a table
create function pg_catalog.pg_stat_get_autovacuum_count(oid) returns bigint
  language internal;

-- statistics: current query of backend
create function pg_catalog.pg_stat_get_backend_activity(integer) returns text
  language internal;

-- statistics: start time for current query of backend
create function pg_catalog.pg_stat_get_backend_activity_start(integer) returns timestamp with time zone
  language internal;

-- statistics: address of client connected to backend
create function pg_catalog.pg_stat_get_backend_client_addr(integer) returns inet
  language internal;

-- statistics: port number of client connected to backend
create function pg_catalog.pg_stat_get_backend_client_port(integer) returns integer
  language internal;

-- statistics: database ID of backend
create function pg_catalog.pg_stat_get_backend_dbid(integer) returns oid
  language internal;

-- statistics: currently active backend IDs
create function pg_catalog.pg_stat_get_backend_idset() returns SETOF integer
  language internal;

-- statistics: backend IO statistics
create function pg_catalog.pg_stat_get_backend_io(backend_pid integer, OUT backend_type text, OUT object text, OUT context text, OUT reads bigint, OUT read_bytes numeric, OUT read_time double precision, OUT writes bigint, OUT write_bytes numeric, OUT write_time double precision, OUT writebacks bigint, OUT writeback_time double precision, OUT extends bigint, OUT extend_bytes numeric, OUT extend_time double precision, OUT hits bigint, OUT evictions bigint, OUT reuses bigint, OUT fsyncs bigint, OUT fsync_time double precision, OUT stats_reset timestamp with time zone) returns SETOF record
  language internal;

-- statistics: PID of backend
create function pg_catalog.pg_stat_get_backend_pid(integer) returns integer
  language internal;

-- statistics: start time for current backend session
create function pg_catalog.pg_stat_get_backend_start(integer) returns timestamp with time zone
  language internal;

-- statistics: get subtransaction status of backend
create function pg_catalog.pg_stat_get_backend_subxact(bid integer, OUT subxact_count integer, OUT subxact_overflowed boolean) returns record
  language internal;

-- statistics: user ID of backend
create function pg_catalog.pg_stat_get_backend_userid(integer) returns oid
  language internal;

-- statistics: wait event on which backend is currently waiting
create function pg_catalog.pg_stat_get_backend_wait_event(integer) returns text
  language internal;

-- statistics: wait event type on which backend is currently waiting
create function pg_catalog.pg_stat_get_backend_wait_event_type(integer) returns text
  language internal;

-- statistics: backend WAL activity
create function pg_catalog.pg_stat_get_backend_wal(backend_pid integer, OUT wal_records bigint, OUT wal_fpi bigint, OUT wal_bytes numeric, OUT wal_buffers_full bigint, OUT stats_reset timestamp with time zone) returns record
  language internal;

-- statistics: start time for backend's current transaction
create function pg_catalog.pg_stat_get_backend_xact_start(integer) returns timestamp with time zone
  language internal;

-- statistics: number of buffers written by the bgwriter for cleaning dirty buffers
create function pg_catalog.pg_stat_get_bgwriter_buf_written_clean() returns bigint
  language internal;

-- statistics: number of times the bgwriter stopped processing when it had written too many buffers while cleaning
create function pg_catalog.pg_stat_get_bgwriter_maxwritten_clean() returns bigint
  language internal;

-- statistics: last reset for the bgwriter
create function pg_catalog.pg_stat_get_bgwriter_stat_reset_time() returns timestamp with time zone
  language internal;

-- statistics: number of blocks fetched
create function pg_catalog.pg_stat_get_blocks_fetched(oid) returns bigint
  language internal;

-- statistics: number of blocks found in cache
create function pg_catalog.pg_stat_get_blocks_hit(oid) returns bigint
  language internal;

-- statistics: number of buffer allocations
create function pg_catalog.pg_stat_get_buf_alloc() returns bigint
  language internal;

-- statistics: number of buffers written during checkpoints and restartpoints
create function pg_catalog.pg_stat_get_checkpointer_buffers_written() returns bigint
  language internal;

-- statistics: number of checkpoints performed by the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_num_performed() returns bigint
  language internal;

-- statistics: number of requested checkpoints started by the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_num_requested() returns bigint
  language internal;

-- statistics: number of timed checkpoints started by the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_num_timed() returns bigint
  language internal;

-- statistics: number of restartpoints performed by the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_restartpoints_performed() returns bigint
  language internal;

-- statistics: number of requested restartpoints started by the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_restartpoints_requested() returns bigint
  language internal;

-- statistics: number of timed restartpoints started by the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_restartpoints_timed() returns bigint
  language internal;

-- statistics: number of SLRU buffers written during checkpoints and restartpoints
create function pg_catalog.pg_stat_get_checkpointer_slru_written() returns bigint
  language internal;

-- statistics: last reset for the checkpointer
create function pg_catalog.pg_stat_get_checkpointer_stat_reset_time() returns timestamp with time zone
  language internal;

-- statistics: checkpoint/restartpoint time spent synchronizing buffers to disk, in milliseconds
create function pg_catalog.pg_stat_get_checkpointer_sync_time() returns double precision
  language internal;

-- statistics: checkpoint/restartpoint time spent writing buffers to disk, in milliseconds
create function pg_catalog.pg_stat_get_checkpointer_write_time() returns double precision
  language internal;

-- statistics: session active time, in milliseconds
create function pg_catalog.pg_stat_get_db_active_time(oid) returns double precision
  language internal;

-- statistics: block read time, in milliseconds
create function pg_catalog.pg_stat_get_db_blk_read_time(oid) returns double precision
  language internal;

-- statistics: block write time, in milliseconds
create function pg_catalog.pg_stat_get_db_blk_write_time(oid) returns double precision
  language internal;

-- statistics: blocks fetched for database
create function pg_catalog.pg_stat_get_db_blocks_fetched(oid) returns bigint
  language internal;

-- statistics: blocks found in cache for database
create function pg_catalog.pg_stat_get_db_blocks_hit(oid) returns bigint
  language internal;

-- statistics: checksum failures detected in database
create function pg_catalog.pg_stat_get_db_checksum_failures(oid) returns bigint
  language internal;

-- statistics: when last checksum failure was detected in database
create function pg_catalog.pg_stat_get_db_checksum_last_failure(oid) returns timestamp with time zone
  language internal;

-- statistics: recovery conflicts in database
create function pg_catalog.pg_stat_get_db_conflict_all(oid) returns bigint
  language internal;

-- statistics: recovery conflicts in database caused by shared buffer pin
create function pg_catalog.pg_stat_get_db_conflict_bufferpin(oid) returns bigint
  language internal;

-- statistics: recovery conflicts in database caused by relation lock
create function pg_catalog.pg_stat_get_db_conflict_lock(oid) returns bigint
  language internal;

-- statistics: recovery conflicts in database caused by logical replication slot
create function pg_catalog.pg_stat_get_db_conflict_logicalslot(oid) returns bigint
  language internal;

-- statistics: recovery conflicts in database caused by snapshot expiry
create function pg_catalog.pg_stat_get_db_conflict_snapshot(oid) returns bigint
  language internal;

-- statistics: recovery conflicts in database caused by buffer deadlock
create function pg_catalog.pg_stat_get_db_conflict_startup_deadlock(oid) returns bigint
  language internal;

-- statistics: recovery conflicts in database caused by drop tablespace
create function pg_catalog.pg_stat_get_db_conflict_tablespace(oid) returns bigint
  language internal;

-- statistics: deadlocks detected in database
create function pg_catalog.pg_stat_get_db_deadlocks(oid) returns bigint
  language internal;

-- statistics: session idle in transaction time, in milliseconds
create function pg_catalog.pg_stat_get_db_idle_in_transaction_time(oid) returns double precision
  language internal;

-- statistics: number of backends in database
create function pg_catalog.pg_stat_get_db_numbackends(oid) returns integer
  language internal;

-- statistics: number of parallel workers effectively launched by queries
create function pg_catalog.pg_stat_get_db_parallel_workers_launched(oid) returns bigint
  language internal;

-- statistics: number of parallel workers planned to be launched by queries
create function pg_catalog.pg_stat_get_db_parallel_workers_to_launch(oid) returns bigint
  language internal;

-- statistics: session time, in milliseconds
create function pg_catalog.pg_stat_get_db_session_time(oid) returns double precision
  language internal;

-- statistics: total number of sessions
create function pg_catalog.pg_stat_get_db_sessions(oid) returns bigint
  language internal;

-- statistics: number of sessions disconnected by the client closing the network connection
create function pg_catalog.pg_stat_get_db_sessions_abandoned(oid) returns bigint
  language internal;

-- statistics: number of sessions disconnected by fatal errors
create function pg_catalog.pg_stat_get_db_sessions_fatal(oid) returns bigint
  language internal;

-- statistics: number of sessions killed by administrative action
create function pg_catalog.pg_stat_get_db_sessions_killed(oid) returns bigint
  language internal;

-- statistics: last reset for a database
create function pg_catalog.pg_stat_get_db_stat_reset_time(oid) returns timestamp with time zone
  language internal;

-- statistics: number of bytes in temporary files written
create function pg_catalog.pg_stat_get_db_temp_bytes(oid) returns bigint
  language internal;

-- statistics: number of temporary files written
create function pg_catalog.pg_stat_get_db_temp_files(oid) returns bigint
  language internal;

-- statistics: tuples deleted in database
create function pg_catalog.pg_stat_get_db_tuples_deleted(oid) returns bigint
  language internal;

-- statistics: tuples fetched for database
create function pg_catalog.pg_stat_get_db_tuples_fetched(oid) returns bigint
  language internal;

-- statistics: tuples inserted in database
create function pg_catalog.pg_stat_get_db_tuples_inserted(oid) returns bigint
  language internal;

-- statistics: tuples returned for database
create function pg_catalog.pg_stat_get_db_tuples_returned(oid) returns bigint
  language internal;

-- statistics: tuples updated in database
create function pg_catalog.pg_stat_get_db_tuples_updated(oid) returns bigint
  language internal;

-- statistics: transactions committed
create function pg_catalog.pg_stat_get_db_xact_commit(oid) returns bigint
  language internal;

-- statistics: transactions rolled back
create function pg_catalog.pg_stat_get_db_xact_rollback(oid) returns bigint
  language internal;

-- statistics: number of dead tuples
create function pg_catalog.pg_stat_get_dead_tuples(oid) returns bigint
  language internal;

-- statistics: number of function calls
create function pg_catalog.pg_stat_get_function_calls(oid) returns bigint
  language internal;

-- statistics: self execution time of function, in milliseconds
create function pg_catalog.pg_stat_get_function_self_time(oid) returns double precision
  language internal;

-- statistics: total execution time of function, in milliseconds
create function pg_catalog.pg_stat_get_function_total_time(oid) returns double precision
  language internal;

-- statistics: number of tuples inserted since last vacuum
create function pg_catalog.pg_stat_get_ins_since_vacuum(oid) returns bigint
  language internal;

-- statistics: per backend type IO statistics
create function pg_catalog.pg_stat_get_io(OUT backend_type text, OUT object text, OUT context text, OUT reads bigint, OUT read_bytes numeric, OUT read_time double precision, OUT writes bigint, OUT write_bytes numeric, OUT write_time double precision, OUT writebacks bigint, OUT writeback_time double precision, OUT extends bigint, OUT extend_bytes numeric, OUT extend_time double precision, OUT hits bigint, OUT evictions bigint, OUT reuses bigint, OUT fsyncs bigint, OUT fsync_time double precision, OUT stats_reset timestamp with time zone) returns SETOF record
  language internal;

-- statistics: last manual analyze time for a table
create function pg_catalog.pg_stat_get_last_analyze_time(oid) returns timestamp with time zone
  language internal;

-- statistics: last auto analyze time for a table
create function pg_catalog.pg_stat_get_last_autoanalyze_time(oid) returns timestamp with time zone
  language internal;

-- statistics: last auto vacuum time for a table
create function pg_catalog.pg_stat_get_last_autovacuum_time(oid) returns timestamp with time zone
  language internal;

-- statistics: last manual vacuum time for a table
create function pg_catalog.pg_stat_get_last_vacuum_time(oid) returns timestamp with time zone
  language internal;

-- statistics: time of the last scan for table/index
create function pg_catalog.pg_stat_get_lastscan(oid) returns timestamp with time zone
  language internal;

-- statistics: number of live tuples
create function pg_catalog.pg_stat_get_live_tuples(oid) returns bigint
  language internal;

-- statistics: number of tuples changed since last analyze
create function pg_catalog.pg_stat_get_mod_since_analyze(oid) returns bigint
  language internal;

-- statistics: number of scans done for table/index
create function pg_catalog.pg_stat_get_numscans(oid) returns bigint
  language internal;

-- statistics: information about progress of backends running maintenance command
create function pg_catalog.pg_stat_get_progress_info(cmdtype text, OUT pid integer, OUT datid oid, OUT relid oid, OUT param1 bigint, OUT param2 bigint, OUT param3 bigint, OUT param4 bigint, OUT param5 bigint, OUT param6 bigint, OUT param7 bigint, OUT param8 bigint, OUT param9 bigint, OUT param10 bigint, OUT param11 bigint, OUT param12 bigint, OUT param13 bigint, OUT param14 bigint, OUT param15 bigint, OUT param16 bigint, OUT param17 bigint, OUT param18 bigint, OUT param19 bigint, OUT param20 bigint) returns SETOF record
  language internal;

-- statistics: information about WAL prefetching
create function pg_catalog.pg_stat_get_recovery_prefetch(OUT stats_reset timestamp with time zone, OUT prefetch bigint, OUT hit bigint, OUT skip_init bigint, OUT skip_new bigint, OUT skip_fpw bigint, OUT skip_rep bigint, OUT wal_distance integer, OUT block_distance integer, OUT io_depth integer) returns SETOF record
  language internal;

-- statistics: information about replication slot
create function pg_catalog.pg_stat_get_replication_slot(slot_name text, OUT slot_name text, OUT spill_txns bigint, OUT spill_count bigint, OUT spill_bytes bigint, OUT stream_txns bigint, OUT stream_count bigint, OUT stream_bytes bigint, OUT total_txns bigint, OUT total_bytes bigint, OUT stats_reset timestamp with time zone) returns record
  language internal;

-- statistics: information about SLRU caches
create function pg_catalog.pg_stat_get_slru(OUT name text, OUT blks_zeroed bigint, OUT blks_hit bigint, OUT blks_read bigint, OUT blks_written bigint, OUT blks_exists bigint, OUT flushes bigint, OUT truncates bigint, OUT stats_reset timestamp with time zone) returns SETOF record
  language internal;

-- statistics: timestamp of the current statistics snapshot
create function pg_catalog.pg_stat_get_snapshot_timestamp() returns timestamp with time zone
  language internal;

-- statistics: information about subscription
create function pg_catalog.pg_stat_get_subscription(subid oid, OUT subid oid, OUT relid oid, OUT pid integer, OUT leader_pid integer, OUT received_lsn pg_lsn, OUT last_msg_send_time timestamp with time zone, OUT last_msg_receipt_time timestamp with time zone, OUT latest_end_lsn pg_lsn, OUT latest_end_time timestamp with time zone, OUT worker_type text) returns SETOF record
  language internal;

-- statistics: information about subscription stats
create function pg_catalog.pg_stat_get_subscription_stats(subid oid, OUT subid oid, OUT apply_error_count bigint, OUT sync_error_count bigint, OUT confl_insert_exists bigint, OUT confl_update_origin_differs bigint, OUT confl_update_exists bigint, OUT confl_update_missing bigint, OUT confl_delete_origin_differs bigint, OUT confl_delete_missing bigint, OUT confl_multiple_unique_conflicts bigint, OUT stats_reset timestamp with time zone) returns record
  language internal;

-- total analyze time, in milliseconds
create function pg_catalog.pg_stat_get_total_analyze_time(oid) returns double precision
  language internal;

-- total autoanalyze time, in milliseconds
create function pg_catalog.pg_stat_get_total_autoanalyze_time(oid) returns double precision
  language internal;

-- total autovacuum time, in milliseconds
create function pg_catalog.pg_stat_get_total_autovacuum_time(oid) returns double precision
  language internal;

-- total vacuum time, in milliseconds
create function pg_catalog.pg_stat_get_total_vacuum_time(oid) returns double precision
  language internal;

-- statistics: number of tuples deleted
create function pg_catalog.pg_stat_get_tuples_deleted(oid) returns bigint
  language internal;

-- statistics: number of tuples fetched by idxscan
create function pg_catalog.pg_stat_get_tuples_fetched(oid) returns bigint
  language internal;

-- statistics: number of tuples hot updated
create function pg_catalog.pg_stat_get_tuples_hot_updated(oid) returns bigint
  language internal;

-- statistics: number of tuples inserted
create function pg_catalog.pg_stat_get_tuples_inserted(oid) returns bigint
  language internal;

-- statistics: number of tuples updated onto a new page
create function pg_catalog.pg_stat_get_tuples_newpage_updated(oid) returns bigint
  language internal;

-- statistics: number of tuples read by seqscan
create function pg_catalog.pg_stat_get_tuples_returned(oid) returns bigint
  language internal;

-- statistics: number of tuples updated
create function pg_catalog.pg_stat_get_tuples_updated(oid) returns bigint
  language internal;

-- statistics: number of manual vacuums for a table
create function pg_catalog.pg_stat_get_vacuum_count(oid) returns bigint
  language internal;

-- statistics: information about WAL activity
create function pg_catalog.pg_stat_get_wal(OUT wal_records bigint, OUT wal_fpi bigint, OUT wal_bytes numeric, OUT wal_buffers_full bigint, OUT stats_reset timestamp with time zone) returns record
  language internal;

-- statistics: information about WAL receiver
create function pg_catalog.pg_stat_get_wal_receiver(OUT pid integer, OUT status text, OUT receive_start_lsn pg_lsn, OUT receive_start_tli integer, OUT written_lsn pg_lsn, OUT flushed_lsn pg_lsn, OUT received_tli integer, OUT last_msg_send_time timestamp with time zone, OUT last_msg_receipt_time timestamp with time zone, OUT latest_end_lsn pg_lsn, OUT latest_end_time timestamp with time zone, OUT slot_name text, OUT sender_host text, OUT sender_port integer, OUT conninfo text) returns record
  language internal;

-- statistics: information about currently active replication
create function pg_catalog.pg_stat_get_wal_senders(OUT pid integer, OUT state text, OUT sent_lsn pg_lsn, OUT write_lsn pg_lsn, OUT flush_lsn pg_lsn, OUT replay_lsn pg_lsn, OUT write_lag interval, OUT flush_lag interval, OUT replay_lag interval, OUT sync_priority integer, OUT sync_state text, OUT reply_time timestamp with time zone) returns SETOF record
  language internal;

-- statistics: number of blocks fetched in current transaction
create function pg_catalog.pg_stat_get_xact_blocks_fetched(oid) returns bigint
  language internal;

-- statistics: number of blocks found in cache in current transaction
create function pg_catalog.pg_stat_get_xact_blocks_hit(oid) returns bigint
  language internal;

-- statistics: number of function calls in current transaction
create function pg_catalog.pg_stat_get_xact_function_calls(oid) returns bigint
  language internal;

-- statistics: self execution time of function in current transaction, in milliseconds
create function pg_catalog.pg_stat_get_xact_function_self_time(oid) returns double precision
  language internal;

-- statistics: total execution time of function in current transaction, in milliseconds
create function pg_catalog.pg_stat_get_xact_function_total_time(oid) returns double precision
  language internal;

-- statistics: number of scans done for table/index in current transaction
create function pg_catalog.pg_stat_get_xact_numscans(oid) returns bigint
  language internal;

-- statistics: number of tuples deleted in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_deleted(oid) returns bigint
  language internal;

-- statistics: number of tuples fetched by idxscan in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_fetched(oid) returns bigint
  language internal;

-- statistics: number of tuples hot updated in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_hot_updated(oid) returns bigint
  language internal;

-- statistics: number of tuples inserted in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_inserted(oid) returns bigint
  language internal;

-- statistics: number of tuples updated onto a new page in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_newpage_updated(oid) returns bigint
  language internal;

-- statistics: number of tuples read by seqscan in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_returned(oid) returns bigint
  language internal;

-- statistics: number of tuples updated in current transaction
create function pg_catalog.pg_stat_get_xact_tuples_updated(oid) returns bigint
  language internal;

-- statistics: check if a stats object exists
create function pg_catalog.pg_stat_have_stats(text, oid, bigint) returns boolean
  language internal;

-- statistics: reset collected statistics for current database
create function pg_catalog.pg_stat_reset() returns void
  language internal;

-- statistics: reset statistics for a single backend
create function pg_catalog.pg_stat_reset_backend_stats(integer) returns void
  language internal;

-- statistics: reset collected statistics for a single replication slot
create function pg_catalog.pg_stat_reset_replication_slot(text) returns void
  language internal;

-- statistics: reset collected statistics shared across the cluster
create function pg_catalog.pg_stat_reset_shared(target text DEFAULT NULL::text) returns void
  language internal;

-- statistics: reset collected statistics for a single function in the current database
create function pg_catalog.pg_stat_reset_single_function_counters(oid) returns void
  language internal;

-- statistics: reset collected statistics for a single table or index in the current database or shared across all databases in the cluster
create function pg_catalog.pg_stat_reset_single_table_counters(oid) returns void
  language internal;

-- statistics: reset collected statistics for a single SLRU
create function pg_catalog.pg_stat_reset_slru(target text DEFAULT NULL::text) returns void
  language internal;

-- statistics: reset collected statistics for a single subscription
create function pg_catalog.pg_stat_reset_subscription_stats(oid) returns void
  language internal;

-- is statistics object visible in search path?
create function pg_catalog.pg_statistics_obj_is_visible(oid) returns boolean
  language internal;

-- stop making pinned objects during initdb
create function pg_catalog.pg_stop_making_pinned_objects() returns void
  language internal;

-- switch to new wal file
create function pg_catalog.pg_switch_wal() returns pg_lsn
  language internal;

-- sync replication slots from the primary to the standby
create function pg_catalog.pg_sync_replication_slots() returns void
  language internal;

-- is table visible in search path?
create function pg_catalog.pg_table_is_visible(oid) returns boolean
  language internal;

-- disk space usage for the specified table, including TOAST, free space and visibility map
create function pg_catalog.pg_table_size(regclass) returns bigint
  language internal;

-- get OIDs of databases in a tablespace
create function pg_catalog.pg_tablespace_databases(oid) returns SETOF oid
  language internal;

-- tablespace location
create function pg_catalog.pg_tablespace_location(oid) returns text
  language internal;

-- total disk space usage for the specified tablespace
create function pg_catalog.pg_tablespace_size(name) returns bigint
  language internal;

-- total disk space usage for the specified tablespace
create function pg_catalog.pg_tablespace_size(oid) returns bigint
  language internal;

-- terminate a server process
create function pg_catalog.pg_terminate_backend(pid integer, timeout bigint DEFAULT 0) returns boolean
  language internal;

-- get abbreviations from timezone_abbreviations
create function pg_catalog.pg_timezone_abbrevs_abbrevs(OUT abbrev text, OUT utc_offset interval, OUT is_dst boolean) returns SETOF record
  language internal;

-- get abbreviations from current timezone
create function pg_catalog.pg_timezone_abbrevs_zone(OUT abbrev text, OUT utc_offset interval, OUT is_dst boolean) returns SETOF record
  language internal;

-- get the available time zone names
create function pg_catalog.pg_timezone_names(OUT name text, OUT abbrev text, OUT utc_offset interval, OUT is_dst boolean) returns SETOF record
  language internal;

-- total disk space usage for the specified table and associated indexes
create function pg_catalog.pg_total_relation_size(regclass) returns bigint
  language internal;

-- current trigger depth
create function pg_catalog.pg_trigger_depth() returns integer
  language internal;

-- obtain exclusive advisory lock if available
create function pg_catalog.pg_try_advisory_lock(bigint) returns boolean
  language internal;

-- obtain exclusive advisory lock if available
create function pg_catalog.pg_try_advisory_lock(integer, integer) returns boolean
  language internal;

-- obtain shared advisory lock if available
create function pg_catalog.pg_try_advisory_lock_shared(bigint) returns boolean
  language internal;

-- obtain shared advisory lock if available
create function pg_catalog.pg_try_advisory_lock_shared(integer, integer) returns boolean
  language internal;

-- obtain exclusive advisory lock if available
create function pg_catalog.pg_try_advisory_xact_lock(bigint) returns boolean
  language internal;

-- obtain exclusive advisory lock if available
create function pg_catalog.pg_try_advisory_xact_lock(integer, integer) returns boolean
  language internal;

-- obtain shared advisory lock if available
create function pg_catalog.pg_try_advisory_xact_lock_shared(bigint) returns boolean
  language internal;

-- obtain shared advisory lock if available
create function pg_catalog.pg_try_advisory_xact_lock_shared(integer, integer) returns boolean
  language internal;

-- is text search configuration visible in search path?
create function pg_catalog.pg_ts_config_is_visible(oid) returns boolean
  language internal;

-- is text search dictionary visible in search path?
create function pg_catalog.pg_ts_dict_is_visible(oid) returns boolean
  language internal;

-- is text search parser visible in search path?
create function pg_catalog.pg_ts_parser_is_visible(oid) returns boolean
  language internal;

-- is text search template visible in search path?
create function pg_catalog.pg_ts_template_is_visible(oid) returns boolean
  language internal;

-- is type visible in search path?
create function pg_catalog.pg_type_is_visible(oid) returns boolean
  language internal;

-- type of the argument
create function pg_catalog.pg_typeof("any") returns regtype
  language internal;

-- is xid8 visible in snapshot?
create function pg_catalog.pg_visible_in_snapshot(xid8, pg_snapshot) returns boolean
  language internal;

-- difference in bytes, given two wal locations
create function pg_catalog.pg_wal_lsn_diff(pg_lsn, pg_lsn) returns numeric
  language internal;

-- pause wal replay
create function pg_catalog.pg_wal_replay_pause() returns void
  language internal;

-- resume wal replay, if it was paused
create function pg_catalog.pg_wal_replay_resume() returns void
  language internal;

-- contents of a WAL summary file
create function pg_catalog.pg_wal_summary_contents(tli bigint, start_lsn pg_lsn, end_lsn pg_lsn, OUT relfilenode oid, OUT reltablespace oid, OUT reldatabase oid, OUT relforknumber smallint, OUT relblocknumber bigint, OUT is_limit_block boolean) returns SETOF record
  language internal;

-- wal filename, given a wal location
create function pg_catalog.pg_walfile_name(pg_lsn) returns text
  language internal;

-- wal filename and byte offset, given a wal location
create function pg_catalog.pg_walfile_name_offset(lsn pg_lsn, OUT file_name text, OUT file_offset integer) returns record
  language internal;

-- get commit timestamp of a transaction
create function pg_catalog.pg_xact_commit_timestamp(xid) returns timestamp with time zone
  language internal;

-- get commit timestamp and replication origin of a transaction
create function pg_catalog.pg_xact_commit_timestamp_origin(xid xid, OUT "timestamp" timestamp with time zone, OUT roident oid) returns record
  language internal;

-- commit status of transaction
create function pg_catalog.pg_xact_status(xid8) returns text
  language internal;

-- transform to tsquery
create function pg_catalog.phraseto_tsquery(regconfig, text) returns tsquery
  language internal;

-- transform to tsquery
create function pg_catalog.phraseto_tsquery(text) returns tsquery
  language internal;

-- PI
create function pg_catalog.pi() returns double precision
  language internal;

-- transform to tsquery
create function pg_catalog.plainto_tsquery(regconfig, text) returns tsquery
  language internal;

-- transform to tsquery
create function pg_catalog.plainto_tsquery(text) returns tsquery
  language internal;

-- center of
create function pg_catalog.point(box) returns point
  language internal;

-- center of
create function pg_catalog.point(circle) returns point
  language internal;

-- convert x, y to point
create function pg_catalog.point(double precision, double precision) returns point
  language internal;

-- center of
create function pg_catalog.point(lseg) returns point
  language internal;

-- center of
create function pg_catalog.point(polygon) returns point
  language internal;

-- implementation of |>> operator
create function pg_catalog.point_above(point, point) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.point_add(point, point) returns point
  language internal;

-- implementation of <<| operator
create function pg_catalog.point_below(point, point) returns boolean
  language internal;

-- implementation of <-> operator
create function pg_catalog.point_distance(point, point) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.point_div(point, point) returns point
  language internal;

-- implementation of ~= operator
create function pg_catalog.point_eq(point, point) returns boolean
  language internal;

-- implementation of ?- operator
create function pg_catalog.point_horiz(point, point) returns boolean
  language internal;

-- I/O
create function pg_catalog.point_in(cstring) returns point
  language internal;

-- implementation of << operator
create function pg_catalog.point_left(point, point) returns boolean
  language internal;

-- implementation of * operator
create function pg_catalog.point_mul(point, point) returns point
  language internal;

-- implementation of <> operator
create function pg_catalog.point_ne(point, point) returns boolean
  language internal;

-- I/O
create function pg_catalog.point_out(point) returns cstring
  language internal;

-- I/O
create function pg_catalog.point_recv(internal) returns point
  language internal;

-- implementation of >> operator
create function pg_catalog.point_right(point, point) returns boolean
  language internal;

-- I/O
create function pg_catalog.point_send(point) returns bytea
  language internal;

-- implementation of - operator
create function pg_catalog.point_sub(point, point) returns point
  language internal;

-- implementation of ?| operator
create function pg_catalog.point_vert(point, point) returns boolean
  language internal;

-- implementation of |>> operator
create function pg_catalog.poly_above(polygon, polygon) returns boolean
  language internal;

-- implementation of <<| operator
create function pg_catalog.poly_below(polygon, polygon) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.poly_center(polygon) returns point
  language internal;

-- implementation of @> operator
create function pg_catalog.poly_contain(polygon, polygon) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.poly_contain_pt(polygon, point) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.poly_contained(polygon, polygon) returns boolean
  language internal;

-- implementation of <-> operator
create function pg_catalog.poly_distance(polygon, polygon) returns double precision
  language internal;

-- I/O
create function pg_catalog.poly_in(cstring) returns polygon
  language internal;

-- implementation of << operator
create function pg_catalog.poly_left(polygon, polygon) returns boolean
  language internal;

-- implementation of # operator
create function pg_catalog.poly_npoints(polygon) returns integer
  language internal;

-- I/O
create function pg_catalog.poly_out(polygon) returns cstring
  language internal;

-- implementation of |&> operator
create function pg_catalog.poly_overabove(polygon, polygon) returns boolean
  language internal;

-- implementation of &<| operator
create function pg_catalog.poly_overbelow(polygon, polygon) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.poly_overlap(polygon, polygon) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.poly_overleft(polygon, polygon) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.poly_overright(polygon, polygon) returns boolean
  language internal;

-- I/O
create function pg_catalog.poly_recv(internal) returns polygon
  language internal;

-- implementation of >> operator
create function pg_catalog.poly_right(polygon, polygon) returns boolean
  language internal;

-- implementation of ~= operator
create function pg_catalog.poly_same(polygon, polygon) returns boolean
  language internal;

-- I/O
create function pg_catalog.poly_send(polygon) returns bytea
  language internal;

-- convert box to polygon
create function pg_catalog.polygon(box) returns polygon
  language internal;

-- convert circle to 12-vertex polygon
create function pg_catalog.polygon(circle) returns polygon
  language sql;

-- convert vertex count and circle to polygon
create function pg_catalog.polygon(integer, circle) returns polygon
  language internal;

-- convert path to polygon
create function pg_catalog.polygon(path) returns polygon
  language internal;

-- open path
create function pg_catalog.popen(path) returns path
  language internal;

-- position of sub-bitstring
create function pg_catalog.position(bit, bit) returns integer
  language internal;

-- position of substring
create function pg_catalog.position(bytea, bytea) returns integer
  language internal;

-- position of substring
create function pg_catalog.position(text, text) returns integer
  language internal;

-- join selectivity for position-comparison operators
create function pg_catalog.positionjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity for position-comparison operators
create function pg_catalog.positionsel(internal, oid, internal, integer) returns double precision
  language internal;

-- (internal)
create function pg_catalog.postgresql_fdw_validator(text[], oid) returns boolean
  language internal;

-- exponentiation
create function pg_catalog.pow(double precision, double precision) returns double precision
  language internal;

-- exponentiation
create function pg_catalog.pow(numeric, numeric) returns numeric
  language internal;

-- exponentiation
create function pg_catalog.power(double precision, double precision) returns double precision
  language internal;

-- exponentiation
create function pg_catalog.power(numeric, numeric) returns numeric
  language internal;

-- join selectivity of exact prefix
create function pg_catalog.prefixjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of exact prefix
create function pg_catalog.prefixsel(internal, oid, internal, integer) returns double precision
  language internal;

-- (internal)
create function pg_catalog.prsd_end(internal) returns void
  language internal;

-- (internal)
create function pg_catalog.prsd_headline(internal, internal, tsquery) returns internal
  language internal;

-- (internal)
create function pg_catalog.prsd_lextype(internal) returns internal
  language internal;

-- (internal)
create function pg_catalog.prsd_nexttoken(internal, internal, internal) returns internal
  language internal;

-- (internal)
create function pg_catalog.prsd_start(internal, integer) returns internal
  language internal;

-- implementation of <@ operator
create function pg_catalog.pt_contained_circle(point, circle) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.pt_contained_poly(point, polygon) returns boolean
  language internal;

-- map query result to XML
create function pg_catalog.query_to_xml(query text, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map query result and structure to XML and XML Schema
create function pg_catalog.query_to_xml_and_xmlschema(query text, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map query result structure to XML Schema
create function pg_catalog.query_to_xmlschema(query text, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- show real useful query for GiST index
create function pg_catalog.querytree(tsquery) returns text
  language internal;

-- quote an identifier for usage in a querystring
create function pg_catalog.quote_ident(text) returns text
  language internal;

-- quote a data value for usage in a querystring
create function pg_catalog.quote_literal(anyelement) returns text
  language sql;

-- quote a literal for usage in a querystring
create function pg_catalog.quote_literal(text) returns text
  language internal;

-- quote a possibly-null data value for usage in a querystring
create function pg_catalog.quote_nullable(anyelement) returns text
  language sql;

-- quote a possibly-null literal for usage in a querystring
create function pg_catalog.quote_nullable(text) returns text
  language internal;

-- degrees to radians
create function pg_catalog.radians(double precision) returns double precision
  language internal;

-- radius of circle
create function pg_catalog.radius(circle) returns double precision
  language internal;

-- random value
create function pg_catalog.random() returns double precision
  language internal;

-- random bigint in range
create function pg_catalog.random(min bigint, max bigint) returns bigint
  language internal;

-- random integer in range
create function pg_catalog.random(min integer, max integer) returns integer
  language internal;

-- random numeric in range
create function pg_catalog.random(min numeric, max numeric) returns numeric
  language internal;

-- random value from normal distribution
create function pg_catalog.random_normal(mean double precision DEFAULT 0, stddev double precision DEFAULT 1) returns double precision
  language internal;

-- implementation of -|- operator
create function pg_catalog.range_adjacent(anyrange, anyrange) returns boolean
  language internal;

-- implementation of -|- operator
create function pg_catalog.range_adjacent_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- implementation of >> operator
create function pg_catalog.range_after(anyrange, anyrange) returns boolean
  language internal;

-- implementation of >> operator
create function pg_catalog.range_after_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- combine aggregate input into a multirange
create aggregate pg_catalog.range_agg(anymultirange) (
  sfunc = multirange_agg_transfn,
  stype = internal,
  finalfunc = multirange_agg_finalfn
);

-- combine aggregate input into a multirange
create aggregate pg_catalog.range_agg(anyrange) (
  sfunc = range_agg_transfn,
  stype = internal,
  finalfunc = range_agg_finalfn
);

-- aggregate final function
create function pg_catalog.range_agg_finalfn(internal, anyrange) returns anymultirange
  language internal;

-- aggregate transition function
create function pg_catalog.range_agg_transfn(internal, anyrange) returns internal
  language internal;

-- implementation of << operator
create function pg_catalog.range_before(anyrange, anyrange) returns boolean
  language internal;

-- implementation of << operator
create function pg_catalog.range_before_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- less-equal-greater
create function pg_catalog.range_cmp(anyrange, anyrange) returns integer
  language internal;

-- implementation of <@ operator
create function pg_catalog.range_contained_by(anyrange, anyrange) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.range_contained_by_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.range_contains(anyrange, anyrange) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.range_contains_elem(anyrange, anyelement) returns boolean
  language internal;

-- planner support for range_contains_elem
create function pg_catalog.range_contains_elem_support(internal) returns internal
  language internal;

-- implementation of @> operator
create function pg_catalog.range_contains_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.range_eq(anyrange, anyrange) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.range_ge(anyrange, anyrange) returns boolean
  language internal;

-- GiST support
create function pg_catalog.range_gist_consistent(internal, anyrange, smallint, oid, internal) returns boolean
  language internal;

-- GiST support
create function pg_catalog.range_gist_penalty(internal, internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.range_gist_picksplit(internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.range_gist_same(anyrange, anyrange, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.range_gist_union(internal, internal) returns anyrange
  language internal;

-- implementation of > operator
create function pg_catalog.range_gt(anyrange, anyrange) returns boolean
  language internal;

-- I/O
create function pg_catalog.range_in(cstring, oid, integer) returns anyrange
  language internal;

-- implementation of * operator
create function pg_catalog.range_intersect(anyrange, anyrange) returns anyrange
  language internal;

-- range aggregate by intersecting
create aggregate pg_catalog.range_intersect_agg(anymultirange) (
  sfunc = multirange_intersect_agg_transfn,
  stype = anymultirange,
  combinefunc = multirange_intersect_agg_transfn
);

-- range aggregate by intersecting
create aggregate pg_catalog.range_intersect_agg(anyrange) (
  sfunc = range_intersect_agg_transfn,
  stype = anyrange,
  combinefunc = range_intersect_agg_transfn
);

-- range aggregate by intersecting
create function pg_catalog.range_intersect_agg_transfn(anyrange, anyrange) returns anyrange
  language internal;

-- implementation of <= operator
create function pg_catalog.range_le(anyrange, anyrange) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.range_lt(anyrange, anyrange) returns boolean
  language internal;

-- the smallest range which includes the whole multirange
create function pg_catalog.range_merge(anymultirange) returns anyrange
  language internal;

-- the smallest range which includes both of the given ranges
create function pg_catalog.range_merge(anyrange, anyrange) returns anyrange
  language internal;

-- implementation of - operator
create function pg_catalog.range_minus(anyrange, anyrange) returns anyrange
  language internal;

-- implementation of <> operator
create function pg_catalog.range_ne(anyrange, anyrange) returns boolean
  language internal;

-- I/O
create function pg_catalog.range_out(anyrange) returns cstring
  language internal;

-- implementation of && operator
create function pg_catalog.range_overlaps(anyrange, anyrange) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.range_overlaps_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.range_overleft(anyrange, anyrange) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.range_overleft_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.range_overright(anyrange, anyrange) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.range_overright_multirange(anyrange, anymultirange) returns boolean
  language internal;

-- I/O
create function pg_catalog.range_recv(internal, oid, integer) returns anyrange
  language internal;

-- I/O
create function pg_catalog.range_send(anyrange) returns bytea
  language internal;

-- sort support
create function pg_catalog.range_sortsupport(internal) returns void
  language internal;

-- range typanalyze
create function pg_catalog.range_typanalyze(internal) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.range_union(anyrange, anyrange) returns anyrange
  language internal;

-- restriction selectivity for range operators
create function pg_catalog.rangesel(internal, oid, internal, integer) returns double precision
  language internal;

-- integer rank with gaps
create function pg_catalog.rank() returns bigint
  language internal;

-- aggregate final function
create function pg_catalog.rank_final(internal, VARIADIC "any") returns bigint
  language internal;

-- raw array subscripting support
create function pg_catalog.raw_array_subscript_handler(internal) returns internal
  language internal;

-- implementation of = operator
create function pg_catalog.record_eq(record, record) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.record_ge(record, record) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.record_gt(record, record) returns boolean
  language internal;

-- implementation of *= operator
create function pg_catalog.record_image_eq(record, record) returns boolean
  language internal;

-- implementation of *>= operator
create function pg_catalog.record_image_ge(record, record) returns boolean
  language internal;

-- implementation of *> operator
create function pg_catalog.record_image_gt(record, record) returns boolean
  language internal;

-- implementation of *<= operator
create function pg_catalog.record_image_le(record, record) returns boolean
  language internal;

-- implementation of *< operator
create function pg_catalog.record_image_lt(record, record) returns boolean
  language internal;

-- implementation of *<> operator
create function pg_catalog.record_image_ne(record, record) returns boolean
  language internal;

-- I/O
create function pg_catalog.record_in(cstring, oid, integer) returns record
  language internal;

-- larger of two
create function pg_catalog.record_larger(record, record) returns record
  language internal;

-- implementation of <= operator
create function pg_catalog.record_le(record, record) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.record_lt(record, record) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.record_ne(record, record) returns boolean
  language internal;

-- I/O
create function pg_catalog.record_out(record) returns cstring
  language internal;

-- I/O
create function pg_catalog.record_recv(internal, oid, integer) returns record
  language internal;

-- I/O
create function pg_catalog.record_send(record) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.record_smaller(record, record) returns record
  language internal;

-- convert text to regclass
create function pg_catalog.regclass(text) returns regclass
  language internal;

-- I/O
create function pg_catalog.regclassin(cstring) returns regclass
  language internal;

-- I/O
create function pg_catalog.regclassout(regclass) returns cstring
  language internal;

-- I/O
create function pg_catalog.regclassrecv(internal) returns regclass
  language internal;

-- I/O
create function pg_catalog.regclasssend(regclass) returns bytea
  language internal;

-- I/O
create function pg_catalog.regcollationin(cstring) returns regcollation
  language internal;

-- I/O
create function pg_catalog.regcollationout(regcollation) returns cstring
  language internal;

-- I/O
create function pg_catalog.regcollationrecv(internal) returns regcollation
  language internal;

-- I/O
create function pg_catalog.regcollationsend(regcollation) returns bytea
  language internal;

-- I/O
create function pg_catalog.regconfigin(cstring) returns regconfig
  language internal;

-- I/O
create function pg_catalog.regconfigout(regconfig) returns cstring
  language internal;

-- I/O
create function pg_catalog.regconfigrecv(internal) returns regconfig
  language internal;

-- I/O
create function pg_catalog.regconfigsend(regconfig) returns bytea
  language internal;

-- I/O
create function pg_catalog.regdictionaryin(cstring) returns regdictionary
  language internal;

-- I/O
create function pg_catalog.regdictionaryout(regdictionary) returns cstring
  language internal;

-- I/O
create function pg_catalog.regdictionaryrecv(internal) returns regdictionary
  language internal;

-- I/O
create function pg_catalog.regdictionarysend(regdictionary) returns bytea
  language internal;

-- join selectivity of regex match
create function pg_catalog.regexeqjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of regex match
create function pg_catalog.regexeqsel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of regex non-match
create function pg_catalog.regexnejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of regex non-match
create function pg_catalog.regexnesel(internal, oid, internal, integer) returns double precision
  language internal;

-- count regexp matches
create function pg_catalog.regexp_count(string text, pattern text) returns integer
  language internal;

-- count regexp matches
create function pg_catalog.regexp_count(string text, pattern text, start integer) returns integer
  language internal;

-- count regexp matches
create function pg_catalog.regexp_count(string text, pattern text, start integer, flags text) returns integer
  language internal;

-- position of regexp match
create function pg_catalog.regexp_instr(string text, pattern text) returns integer
  language internal;

-- position of regexp match
create function pg_catalog.regexp_instr(string text, pattern text, start integer) returns integer
  language internal;

-- position of regexp match
create function pg_catalog.regexp_instr(string text, pattern text, start integer, "N" integer) returns integer
  language internal;

-- position of regexp match
create function pg_catalog.regexp_instr(string text, pattern text, start integer, "N" integer, endoption integer) returns integer
  language internal;

-- position of regexp match
create function pg_catalog.regexp_instr(string text, pattern text, start integer, "N" integer, endoption integer, flags text) returns integer
  language internal;

-- position of regexp match
create function pg_catalog.regexp_instr(string text, pattern text, start integer, "N" integer, endoption integer, flags text, subexpr integer) returns integer
  language internal;

-- test for regexp match
create function pg_catalog.regexp_like(string text, pattern text) returns boolean
  language internal;

-- test for regexp match
create function pg_catalog.regexp_like(string text, pattern text, flags text) returns boolean
  language internal;

-- find first match for regexp
create function pg_catalog.regexp_match(string text, pattern text) returns text[]
  language internal;

-- find first match for regexp
create function pg_catalog.regexp_match(string text, pattern text, flags text) returns text[]
  language internal;

-- find match(es) for regexp
create function pg_catalog.regexp_matches(string text, pattern text) returns SETOF text[]
  language internal;

-- find match(es) for regexp
create function pg_catalog.regexp_matches(string text, pattern text, flags text) returns SETOF text[]
  language internal;

-- replace text using regexp
create function pg_catalog.regexp_replace(string text, pattern text, replacement text) returns text
  language internal;

-- replace text using regexp
create function pg_catalog.regexp_replace(string text, pattern text, replacement text, flags text) returns text
  language internal;

-- replace text using regexp
create function pg_catalog.regexp_replace(string text, pattern text, replacement text, start integer) returns text
  language internal;

-- replace text using regexp
create function pg_catalog.regexp_replace(string text, pattern text, replacement text, start integer, "N" integer) returns text
  language internal;

-- replace text using regexp
create function pg_catalog.regexp_replace(string text, pattern text, replacement text, start integer, "N" integer, flags text) returns text
  language internal;

-- split string by pattern
create function pg_catalog.regexp_split_to_array(string text, pattern text) returns text[]
  language internal;

-- split string by pattern
create function pg_catalog.regexp_split_to_array(string text, pattern text, flags text) returns text[]
  language internal;

-- split string by pattern
create function pg_catalog.regexp_split_to_table(string text, pattern text) returns SETOF text
  language internal;

-- split string by pattern
create function pg_catalog.regexp_split_to_table(string text, pattern text, flags text) returns SETOF text
  language internal;

-- extract substring that matches regexp
create function pg_catalog.regexp_substr(string text, pattern text) returns text
  language internal;

-- extract substring that matches regexp
create function pg_catalog.regexp_substr(string text, pattern text, start integer) returns text
  language internal;

-- extract substring that matches regexp
create function pg_catalog.regexp_substr(string text, pattern text, start integer, "N" integer) returns text
  language internal;

-- extract substring that matches regexp
create function pg_catalog.regexp_substr(string text, pattern text, start integer, "N" integer, flags text) returns text
  language internal;

-- extract substring that matches regexp
create function pg_catalog.regexp_substr(string text, pattern text, start integer, "N" integer, flags text, subexpr integer) returns text
  language internal;

-- I/O
create function pg_catalog.regnamespacein(cstring) returns regnamespace
  language internal;

-- I/O
create function pg_catalog.regnamespaceout(regnamespace) returns cstring
  language internal;

-- I/O
create function pg_catalog.regnamespacerecv(internal) returns regnamespace
  language internal;

-- I/O
create function pg_catalog.regnamespacesend(regnamespace) returns bytea
  language internal;

-- I/O
create function pg_catalog.regoperatorin(cstring) returns regoperator
  language internal;

-- I/O
create function pg_catalog.regoperatorout(regoperator) returns cstring
  language internal;

-- I/O
create function pg_catalog.regoperatorrecv(internal) returns regoperator
  language internal;

-- I/O
create function pg_catalog.regoperatorsend(regoperator) returns bytea
  language internal;

-- I/O
create function pg_catalog.regoperin(cstring) returns regoper
  language internal;

-- I/O
create function pg_catalog.regoperout(regoper) returns cstring
  language internal;

-- I/O
create function pg_catalog.regoperrecv(internal) returns regoper
  language internal;

-- I/O
create function pg_catalog.regopersend(regoper) returns bytea
  language internal;

-- I/O
create function pg_catalog.regprocedurein(cstring) returns regprocedure
  language internal;

-- I/O
create function pg_catalog.regprocedureout(regprocedure) returns cstring
  language internal;

-- I/O
create function pg_catalog.regprocedurerecv(internal) returns regprocedure
  language internal;

-- I/O
create function pg_catalog.regproceduresend(regprocedure) returns bytea
  language internal;

-- I/O
create function pg_catalog.regprocin(cstring) returns regproc
  language internal;

-- I/O
create function pg_catalog.regprocout(regproc) returns cstring
  language internal;

-- I/O
create function pg_catalog.regprocrecv(internal) returns regproc
  language internal;

-- I/O
create function pg_catalog.regprocsend(regproc) returns bytea
  language internal;

-- average of the independent variable (sum(X)/N)
create aggregate pg_catalog.regr_avgx(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_avgx,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- average of the dependent variable (sum(Y)/N)
create aggregate pg_catalog.regr_avgy(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_avgy,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- number of input rows in which both expressions are not null
create aggregate pg_catalog.regr_count(double precision, double precision) (
  sfunc = int8inc_float8_float8,
  stype = bigint,
  combinefunc = int8pl,
  initcond = '0'
);

-- y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs
create aggregate pg_catalog.regr_intercept(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_intercept,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- square of the correlation coefficient
create aggregate pg_catalog.regr_r2(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_r2,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- slope of the least-squares-fit linear equation determined by the (X, Y) pairs
create aggregate pg_catalog.regr_slope(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_slope,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- sum of squares of the independent variable (sum(X^2) - sum(X)^2/N)
create aggregate pg_catalog.regr_sxx(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_sxx,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- sum of products of independent times dependent variable (sum(X*Y) - sum(X) * sum(Y)/N)
create aggregate pg_catalog.regr_sxy(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_sxy,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- sum of squares of the dependent variable (sum(Y^2) - sum(Y)^2/N)
create aggregate pg_catalog.regr_syy(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_regr_syy,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- I/O
create function pg_catalog.regrolein(cstring) returns regrole
  language internal;

-- I/O
create function pg_catalog.regroleout(regrole) returns cstring
  language internal;

-- I/O
create function pg_catalog.regrolerecv(internal) returns regrole
  language internal;

-- I/O
create function pg_catalog.regrolesend(regrole) returns bytea
  language internal;

-- I/O
create function pg_catalog.regtypein(cstring) returns regtype
  language internal;

-- I/O
create function pg_catalog.regtypeout(regtype) returns cstring
  language internal;

-- I/O
create function pg_catalog.regtyperecv(internal) returns regtype
  language internal;

-- I/O
create function pg_catalog.regtypesend(regtype) returns bytea
  language internal;

-- replicate string n times
create function pg_catalog.repeat(text, integer) returns text
  language internal;

-- replace all occurrences in string of old_substr with new_substr
create function pg_catalog.replace(text, text, text) returns text
  language internal;

-- reverse bytea
create function pg_catalog.reverse(bytea) returns bytea
  language internal;

-- reverse text
create function pg_catalog.reverse(text) returns text
  language internal;

-- extract the last n characters
create function pg_catalog.right(text, integer) returns text
  language internal;

-- round to nearest integer
create function pg_catalog.round(double precision) returns double precision
  language internal;

-- value rounded to 'scale' of zero
create function pg_catalog.round(numeric) returns numeric
  language sql;

-- value rounded to 'scale'
create function pg_catalog.round(numeric, integer) returns numeric
  language internal;

-- row number within partition
create function pg_catalog.row_number() returns bigint
  language internal;

-- row security for current context active on table by table oid
create function pg_catalog.row_security_active(oid) returns boolean
  language internal;

-- row security for current context active on table by table name
create function pg_catalog.row_security_active(text) returns boolean
  language internal;

-- map row to json
create function pg_catalog.row_to_json(record) returns json
  language internal;

-- map row to json with optional pretty printing
create function pg_catalog.row_to_json(record, boolean) returns json
  language internal;

-- right-pad string to length
create function pg_catalog.rpad(text, integer) returns text
  language sql;

-- right-pad string to length
create function pg_catalog.rpad(text, integer, text) returns text
  language internal;

-- trim selected bytes from right end of string
create function pg_catalog.rtrim(bytea, bytea) returns bytea
  language internal;

-- trim spaces from right end of string
create function pg_catalog.rtrim(text) returns text
  language internal;

-- trim selected characters from right end of string
create function pg_catalog.rtrim(text, text) returns text
  language internal;

-- hash partition CHECK constraint
create function pg_catalog.satisfies_hash_partition(oid, integer, integer, VARIADIC "any") returns boolean
  language internal;

-- join selectivity of >= and related operators on scalar datatypes
create function pg_catalog.scalargejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of >= and related operators on scalar datatypes
create function pg_catalog.scalargesel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of > and related operators on scalar datatypes
create function pg_catalog.scalargtjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of > and related operators on scalar datatypes
create function pg_catalog.scalargtsel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of <= and related operators on scalar datatypes
create function pg_catalog.scalarlejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of <= and related operators on scalar datatypes
create function pg_catalog.scalarlesel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of < and related operators on scalar datatypes
create function pg_catalog.scalarltjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of < and related operators on scalar datatypes
create function pg_catalog.scalarltsel(internal, oid, internal, integer) returns double precision
  language internal;

-- number of decimal digits in the fractional part
create function pg_catalog.scale(numeric) returns integer
  language internal;

-- map schema contents to XML
create function pg_catalog.schema_to_xml(schema name, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map schema contents and structure to XML and XML Schema
create function pg_catalog.schema_to_xml_and_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map schema structure to XML Schema
create function pg_catalog.schema_to_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- session user name
create function pg_catalog.session_user() returns name
  language internal;

-- set bit
create function pg_catalog.set_bit(bit, integer, integer) returns bit
  language internal;

-- set bit
create function pg_catalog.set_bit(bytea, bigint, integer) returns bytea
  language internal;

-- set byte
create function pg_catalog.set_byte(bytea, integer, integer) returns bytea
  language internal;

-- SET X as a function
create function pg_catalog.set_config(text, text, boolean) returns text
  language internal;

-- change netmask of cidr
create function pg_catalog.set_masklen(cidr, integer) returns cidr
  language internal;

-- change netmask of inet
create function pg_catalog.set_masklen(inet, integer) returns inet
  language internal;

-- set random seed
create function pg_catalog.setseed(double precision) returns void
  language internal;

-- set sequence value
create function pg_catalog.setval(regclass, bigint) returns bigint
  language internal;

-- set sequence value and is_called status
create function pg_catalog.setval(regclass, bigint, boolean) returns bigint
  language internal;

-- set given weight for whole tsvector
create function pg_catalog.setweight(tsvector, "char") returns tsvector
  language internal;

-- set given weight for given lexemes
create function pg_catalog.setweight(tsvector, "char", text[]) returns tsvector
  language internal;

-- SHA-224 hash
create function pg_catalog.sha224(bytea) returns bytea
  language internal;

-- SHA-256 hash
create function pg_catalog.sha256(bytea) returns bytea
  language internal;

-- SHA-384 hash
create function pg_catalog.sha384(bytea) returns bytea
  language internal;

-- SHA-512 hash
create function pg_catalog.sha512(bytea) returns bytea
  language internal;

-- I/O
create function pg_catalog.shell_in(cstring) returns void
  language internal;

-- I/O
create function pg_catalog.shell_out(void) returns cstring
  language internal;

-- internal conversion function for SHIFT_JIS_2004 to EUC_JIS_2004
create function pg_catalog.shift_jis_2004_to_euc_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for SHIFT_JIS_2004 to UTF8
create function pg_catalog.shift_jis_2004_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- get description for object id and shared catalog name
create function pg_catalog.shobj_description(oid, name) returns text
  language sql;

-- sign of value
create function pg_catalog.sign(double precision) returns double precision
  language internal;

-- sign of value
create function pg_catalog.sign(numeric) returns numeric
  language internal;

-- convert SQL regexp pattern to POSIX style
create function pg_catalog.similar_escape(text, text) returns text
  language internal;

-- convert SQL regexp pattern to POSIX style
create function pg_catalog.similar_to_escape(text) returns text
  language internal;

-- convert SQL regexp pattern to POSIX style
create function pg_catalog.similar_to_escape(text, text) returns text
  language internal;

-- sine
create function pg_catalog.sin(double precision) returns double precision
  language internal;

-- sine, degrees
create function pg_catalog.sind(double precision) returns double precision
  language internal;

-- hyperbolic sine
create function pg_catalog.sinh(double precision) returns double precision
  language internal;

-- internal conversion function for SJIS to EUC_JP
create function pg_catalog.sjis_to_euc_jp(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for SJIS to MULE_INTERNAL
create function pg_catalog.sjis_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for SJIS to UTF8
create function pg_catalog.sjis_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- slope between points
create function pg_catalog.slope(point, point) returns double precision
  language internal;

-- SP-GiST support for quad tree over 2-D types represented by their bounding boxes
create function pg_catalog.spg_bbox_quad_config(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over box
create function pg_catalog.spg_box_quad_choose(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over box
create function pg_catalog.spg_box_quad_config(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over box
create function pg_catalog.spg_box_quad_inner_consistent(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over box
create function pg_catalog.spg_box_quad_leaf_consistent(internal, internal) returns boolean
  language internal;

-- SP-GiST support for quad tree over box
create function pg_catalog.spg_box_quad_picksplit(internal, internal) returns void
  language internal;

-- SP-GiST support for k-d tree over point
create function pg_catalog.spg_kd_choose(internal, internal) returns void
  language internal;

-- SP-GiST support for k-d tree over point
create function pg_catalog.spg_kd_config(internal, internal) returns void
  language internal;

-- SP-GiST support for k-d tree over point
create function pg_catalog.spg_kd_inner_consistent(internal, internal) returns void
  language internal;

-- SP-GiST support for k-d tree over point
create function pg_catalog.spg_kd_picksplit(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over polygons
create function pg_catalog.spg_poly_quad_compress(polygon) returns box
  language internal;

-- SP-GiST support for quad tree over point
create function pg_catalog.spg_quad_choose(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over point
create function pg_catalog.spg_quad_config(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over point
create function pg_catalog.spg_quad_inner_consistent(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree and k-d tree over point
create function pg_catalog.spg_quad_leaf_consistent(internal, internal) returns boolean
  language internal;

-- SP-GiST support for quad tree over point
create function pg_catalog.spg_quad_picksplit(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over range
create function pg_catalog.spg_range_quad_choose(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over range
create function pg_catalog.spg_range_quad_config(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over range
create function pg_catalog.spg_range_quad_inner_consistent(internal, internal) returns void
  language internal;

-- SP-GiST support for quad tree over range
create function pg_catalog.spg_range_quad_leaf_consistent(internal, internal) returns boolean
  language internal;

-- SP-GiST support for quad tree over range
create function pg_catalog.spg_range_quad_picksplit(internal, internal) returns void
  language internal;

-- SP-GiST support for radix tree over text
create function pg_catalog.spg_text_choose(internal, internal) returns void
  language internal;

-- SP-GiST support for radix tree over text
create function pg_catalog.spg_text_config(internal, internal) returns void
  language internal;

-- SP-GiST support for radix tree over text
create function pg_catalog.spg_text_inner_consistent(internal, internal) returns void
  language internal;

-- SP-GiST support for radix tree over text
create function pg_catalog.spg_text_leaf_consistent(internal, internal) returns boolean
  language internal;

-- SP-GiST support for radix tree over text
create function pg_catalog.spg_text_picksplit(internal, internal) returns void
  language internal;

-- spgist index access method handler
create function pg_catalog.spghandler(internal) returns index_am_handler
  language internal;

-- split string by field_sep and return field_num
create function pg_catalog.split_part(text, text, integer) returns text
  language internal;

-- square root
create function pg_catalog.sqrt(double precision) returns double precision
  language internal;

-- square root
create function pg_catalog.sqrt(numeric) returns numeric
  language internal;

-- implementation of ^@ operator
create function pg_catalog.starts_with(text, text) returns boolean
  language internal;

-- current statement time
create function pg_catalog.statement_timestamp() returns timestamp with time zone
  language internal;

-- historical alias for stddev_samp
create aggregate pg_catalog.stddev(bigint) (
  sfunc = int8_accum,
  stype = internal,
  finalfunc = numeric_stddev_samp,
  combinefunc = numeric_combine
);

-- historical alias for stddev_samp
create aggregate pg_catalog.stddev(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_stddev_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- historical alias for stddev_samp
create aggregate pg_catalog.stddev(integer) (
  sfunc = int4_accum,
  stype = internal,
  finalfunc = numeric_poly_stddev_samp,
  combinefunc = numeric_poly_combine
);

-- historical alias for stddev_samp
create aggregate pg_catalog.stddev(numeric) (
  sfunc = numeric_accum,
  stype = internal,
  finalfunc = numeric_stddev_samp,
  combinefunc = numeric_combine
);

-- historical alias for stddev_samp
create aggregate pg_catalog.stddev(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_stddev_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- historical alias for stddev_samp
create aggregate pg_catalog.stddev(smallint) (
  sfunc = int2_accum,
  stype = internal,
  finalfunc = numeric_poly_stddev_samp,
  combinefunc = numeric_poly_combine
);

-- population standard deviation of bigint input values
create aggregate pg_catalog.stddev_pop(bigint) (
  sfunc = int8_accum,
  stype = internal,
  finalfunc = numeric_stddev_pop,
  combinefunc = numeric_combine
);

-- population standard deviation of float8 input values
create aggregate pg_catalog.stddev_pop(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_stddev_pop,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- population standard deviation of integer input values
create aggregate pg_catalog.stddev_pop(integer) (
  sfunc = int4_accum,
  stype = internal,
  finalfunc = numeric_poly_stddev_pop,
  combinefunc = numeric_poly_combine
);

-- population standard deviation of numeric input values
create aggregate pg_catalog.stddev_pop(numeric) (
  sfunc = numeric_accum,
  stype = internal,
  finalfunc = numeric_stddev_pop,
  combinefunc = numeric_combine
);

-- population standard deviation of float4 input values
create aggregate pg_catalog.stddev_pop(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_stddev_pop,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- population standard deviation of smallint input values
create aggregate pg_catalog.stddev_pop(smallint) (
  sfunc = int2_accum,
  stype = internal,
  finalfunc = numeric_poly_stddev_pop,
  combinefunc = numeric_poly_combine
);

-- sample standard deviation of bigint input values
create aggregate pg_catalog.stddev_samp(bigint) (
  sfunc = int8_accum,
  stype = internal,
  finalfunc = numeric_stddev_samp,
  combinefunc = numeric_combine
);

-- sample standard deviation of float8 input values
create aggregate pg_catalog.stddev_samp(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_stddev_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- sample standard deviation of integer input values
create aggregate pg_catalog.stddev_samp(integer) (
  sfunc = int4_accum,
  stype = internal,
  finalfunc = numeric_poly_stddev_samp,
  combinefunc = numeric_poly_combine
);

-- sample standard deviation of numeric input values
create aggregate pg_catalog.stddev_samp(numeric) (
  sfunc = numeric_accum,
  stype = internal,
  finalfunc = numeric_stddev_samp,
  combinefunc = numeric_combine
);

-- sample standard deviation of float4 input values
create aggregate pg_catalog.stddev_samp(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_stddev_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- sample standard deviation of smallint input values
create aggregate pg_catalog.stddev_samp(smallint) (
  sfunc = int2_accum,
  stype = internal,
  finalfunc = numeric_poly_stddev_samp,
  combinefunc = numeric_poly_combine
);

-- concatenate aggregate input into a bytea
create aggregate pg_catalog.string_agg(value bytea, delimiter bytea) (
  sfunc = bytea_string_agg_transfn,
  stype = internal,
  finalfunc = bytea_string_agg_finalfn,
  combinefunc = string_agg_combine
);

-- concatenate aggregate input into a string
create aggregate pg_catalog.string_agg(value text, delimiter text) (
  sfunc = string_agg_transfn,
  stype = internal,
  finalfunc = string_agg_finalfn,
  combinefunc = string_agg_combine
);

-- aggregate combine function
create function pg_catalog.string_agg_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.string_agg_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate final function
create function pg_catalog.string_agg_finalfn(internal) returns text
  language internal;

-- aggregate serial function
create function pg_catalog.string_agg_serialize(internal) returns bytea
  language internal;

-- aggregate transition function
create function pg_catalog.string_agg_transfn(internal, text, text) returns internal
  language internal;

-- split delimited text
create function pg_catalog.string_to_array(text, text) returns text[]
  language internal;

-- split delimited text, with null string
create function pg_catalog.string_to_array(text, text, text) returns text[]
  language internal;

-- split delimited text
create function pg_catalog.string_to_table(text, text) returns SETOF text
  language internal;

-- split delimited text, with null string
create function pg_catalog.string_to_table(text, text, text) returns SETOF text
  language internal;

-- strip position information
create function pg_catalog.strip(tsvector) returns tsvector
  language internal;

-- position of substring
create function pg_catalog.strpos(text, text) returns integer
  language internal;

-- extract portion of string
create function pg_catalog.substr(bytea, integer) returns bytea
  language internal;

-- extract portion of string
create function pg_catalog.substr(bytea, integer, integer) returns bytea
  language internal;

-- extract portion of string
create function pg_catalog.substr(text, integer) returns text
  language internal;

-- extract portion of string
create function pg_catalog.substr(text, integer, integer) returns text
  language internal;

-- extract portion of bitstring
create function pg_catalog.substring(bit, integer) returns bit
  language internal;

-- extract portion of bitstring
create function pg_catalog.substring(bit, integer, integer) returns bit
  language internal;

-- extract portion of string
create function pg_catalog.substring(bytea, integer) returns bytea
  language internal;

-- extract portion of string
create function pg_catalog.substring(bytea, integer, integer) returns bytea
  language internal;

-- extract portion of string
create function pg_catalog.substring(text, integer) returns text
  language internal;

-- extract portion of string
create function pg_catalog.substring(text, integer, integer) returns text
  language internal;

-- extract text matching regular expression
create function pg_catalog.substring(text, text) returns text
  language internal;

-- extract text matching SQL regular expression
create function pg_catalog.substring(text, text, text) returns text
  language sql;

-- sum as numeric across all bigint input values
create aggregate pg_catalog.sum(bigint) (
  sfunc = int8_avg_accum,
  stype = internal,
  finalfunc = numeric_poly_sum,
  combinefunc = int8_avg_combine
);

-- sum as float8 across all float8 input values
create aggregate pg_catalog.sum(double precision) (
  sfunc = float8pl,
  stype = double precision,
  combinefunc = float8pl
);

-- sum as bigint across all integer input values
create aggregate pg_catalog.sum(integer) (
  sfunc = int4_sum,
  stype = bigint,
  combinefunc = int8pl
);

-- sum as interval across all interval input values
create aggregate pg_catalog.sum(interval) (
  sfunc = interval_avg_accum,
  stype = internal,
  finalfunc = interval_sum,
  combinefunc = interval_avg_combine
);

-- sum as money across all money input values
create aggregate pg_catalog.sum(money) (
  sfunc = cash_pl,
  stype = money,
  combinefunc = cash_pl
);

-- sum as numeric across all numeric input values
create aggregate pg_catalog.sum(numeric) (
  sfunc = numeric_avg_accum,
  stype = internal,
  finalfunc = numeric_sum,
  combinefunc = numeric_avg_combine
);

-- sum as float4 across all float4 input values
create aggregate pg_catalog.sum(real) (
  sfunc = float4pl,
  stype = real,
  combinefunc = float4pl
);

-- sum as bigint across all smallint input values
create aggregate pg_catalog.sum(smallint) (
  sfunc = int2_sum,
  stype = bigint,
  combinefunc = int8pl
);

-- trigger to suppress updates when new and old records match
create function pg_catalog.suppress_redundant_updates_trigger() returns trigger
  language internal;

-- SYSTEM tablesample method handler
create function pg_catalog.system(internal) returns tsm_handler
  language internal;

-- system user name
create function pg_catalog.system_user() returns text
  language internal;

-- I/O
create function pg_catalog.table_am_handler_in(cstring) returns table_am_handler
  language internal;

-- I/O
create function pg_catalog.table_am_handler_out(table_am_handler) returns cstring
  language internal;

-- map table contents to XML
create function pg_catalog.table_to_xml(tbl regclass, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map table contents and structure to XML and XML Schema
create function pg_catalog.table_to_xml_and_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map table structure to XML Schema
create function pg_catalog.table_to_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- tangent
create function pg_catalog.tan(double precision) returns double precision
  language internal;

-- tangent, degrees
create function pg_catalog.tand(double precision) returns double precision
  language internal;

-- hyperbolic tangent
create function pg_catalog.tanh(double precision) returns double precision
  language internal;

-- convert char to text
create function pg_catalog.text("char") returns text
  language internal;

-- convert boolean to text
create function pg_catalog.text(boolean) returns text
  language internal;

-- convert char(n) to text
create function pg_catalog.text(character) returns text
  language internal;

-- show all parts of inet/cidr value
create function pg_catalog.text(inet) returns text
  language internal;

-- convert name to text
create function pg_catalog.text(name) returns text
  language internal;

-- serialize an XML value to a character string
create function pg_catalog.text(xml) returns text
  language internal;

-- implementation of >= operator
create function pg_catalog.text_ge(text, text) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.text_gt(text, text) returns boolean
  language internal;

-- larger of two
create function pg_catalog.text_larger(text, text) returns text
  language internal;

-- implementation of <= operator
create function pg_catalog.text_le(text, text) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.text_lt(text, text) returns boolean
  language internal;

-- implementation of ~>=~ operator
create function pg_catalog.text_pattern_ge(text, text) returns boolean
  language internal;

-- implementation of ~>~ operator
create function pg_catalog.text_pattern_gt(text, text) returns boolean
  language internal;

-- implementation of ~<=~ operator
create function pg_catalog.text_pattern_le(text, text) returns boolean
  language internal;

-- implementation of ~<~ operator
create function pg_catalog.text_pattern_lt(text, text) returns boolean
  language internal;

-- smaller of two
create function pg_catalog.text_smaller(text, text) returns text
  language internal;

-- planner support for text_starts_with
create function pg_catalog.text_starts_with_support(internal) returns internal
  language internal;

-- implementation of || operator
create function pg_catalog.textanycat(text, anynonarray) returns text
  language sql;

-- implementation of || operator
create function pg_catalog.textcat(text, text) returns text
  language internal;

-- implementation of = operator
create function pg_catalog.texteq(text, text) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.texteqname(text, name) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.textgename(text, name) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.textgtname(text, name) returns boolean
  language internal;

-- implementation of ~~* operator
create function pg_catalog.texticlike(text, text) returns boolean
  language internal;

-- planner support for texticlike
create function pg_catalog.texticlike_support(internal) returns internal
  language internal;

-- implementation of !~~* operator
create function pg_catalog.texticnlike(text, text) returns boolean
  language internal;

-- implementation of ~* operator
create function pg_catalog.texticregexeq(text, text) returns boolean
  language internal;

-- planner support for texticregexeq
create function pg_catalog.texticregexeq_support(internal) returns internal
  language internal;

-- implementation of !~* operator
create function pg_catalog.texticregexne(text, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.textin(cstring) returns text
  language internal;

-- length
create function pg_catalog.textlen(text) returns integer
  language internal;

-- implementation of <= operator
create function pg_catalog.textlename(text, name) returns boolean
  language internal;

-- implementation of ~~ operator
create function pg_catalog.textlike(text, text) returns boolean
  language internal;

-- planner support for textlike
create function pg_catalog.textlike_support(internal) returns internal
  language internal;

-- implementation of < operator
create function pg_catalog.textltname(text, name) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.textne(text, text) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.textnename(text, name) returns boolean
  language internal;

-- implementation of !~~ operator
create function pg_catalog.textnlike(text, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.textout(text) returns cstring
  language internal;

-- I/O
create function pg_catalog.textrecv(internal) returns text
  language internal;

-- implementation of ~ operator
create function pg_catalog.textregexeq(text, text) returns boolean
  language internal;

-- planner support for textregexeq
create function pg_catalog.textregexeq_support(internal) returns internal
  language internal;

-- implementation of !~ operator
create function pg_catalog.textregexne(text, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.textsend(text) returns bytea
  language internal;

-- (internal)
create function pg_catalog.thesaurus_init(internal) returns internal
  language internal;

-- (internal)
create function pg_catalog.thesaurus_lexize(internal, internal, internal, internal) returns internal
  language internal;

-- implementation of = operator
create function pg_catalog.tideq(tid, tid) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.tidge(tid, tid) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.tidgt(tid, tid) returns boolean
  language internal;

-- I/O
create function pg_catalog.tidin(cstring) returns tid
  language internal;

-- larger of two
create function pg_catalog.tidlarger(tid, tid) returns tid
  language internal;

-- implementation of <= operator
create function pg_catalog.tidle(tid, tid) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.tidlt(tid, tid) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.tidne(tid, tid) returns boolean
  language internal;

-- I/O
create function pg_catalog.tidout(tid) returns cstring
  language internal;

-- I/O
create function pg_catalog.tidrecv(internal) returns tid
  language internal;

-- I/O
create function pg_catalog.tidsend(tid) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.tidsmaller(tid, tid) returns tid
  language internal;

-- convert interval to time
create function pg_catalog.time(interval) returns time without time zone
  language internal;

-- convert time with time zone to time
create function pg_catalog.time(time with time zone) returns time without time zone
  language internal;

-- adjust time precision
create function pg_catalog.time(time without time zone, integer) returns time without time zone
  language internal;

-- convert timestamp with time zone to time
create function pg_catalog.time(timestamp with time zone) returns time without time zone
  language internal;

-- convert timestamp to time
create function pg_catalog.time(timestamp without time zone) returns time without time zone
  language internal;

-- less-equal-greater
create function pg_catalog.time_cmp(time without time zone, time without time zone) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.time_eq(time without time zone, time without time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.time_ge(time without time zone, time without time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.time_gt(time without time zone, time without time zone) returns boolean
  language internal;

-- hash
create function pg_catalog.time_hash(time without time zone) returns integer
  language internal;

-- hash
create function pg_catalog.time_hash_extended(time without time zone, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.time_in(cstring, oid, integer) returns time without time zone
  language internal;

-- larger of two
create function pg_catalog.time_larger(time without time zone, time without time zone) returns time without time zone
  language internal;

-- implementation of <= operator
create function pg_catalog.time_le(time without time zone, time without time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.time_lt(time without time zone, time without time zone) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.time_mi_interval(time without time zone, interval) returns time without time zone
  language internal;

-- implementation of - operator
create function pg_catalog.time_mi_time(time without time zone, time without time zone) returns interval
  language internal;

-- implementation of <> operator
create function pg_catalog.time_ne(time without time zone, time without time zone) returns boolean
  language internal;

-- I/O
create function pg_catalog.time_out(time without time zone) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.time_pl_interval(time without time zone, interval) returns time without time zone
  language internal;

-- I/O
create function pg_catalog.time_recv(internal, oid, integer) returns time without time zone
  language internal;

-- I/O
create function pg_catalog.time_send(time without time zone) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.time_smaller(time without time zone, time without time zone) returns time without time zone
  language internal;

-- planner support for time length coercion
create function pg_catalog.time_support(internal) returns internal
  language internal;

-- implementation of + operator
create function pg_catalog.timedate_pl(time without time zone, date) returns timestamp without time zone
  language sql;

-- current date and time - increments during transactions
create function pg_catalog.timeofday() returns text
  language internal;

-- convert date to timestamp
create function pg_catalog.timestamp(date) returns timestamp without time zone
  language internal;

-- convert date and time to timestamp
create function pg_catalog.timestamp(date, time without time zone) returns timestamp without time zone
  language internal;

-- convert timestamp with time zone to timestamp
create function pg_catalog.timestamp(timestamp with time zone) returns timestamp without time zone
  language internal;

-- adjust timestamp precision
create function pg_catalog.timestamp(timestamp without time zone, integer) returns timestamp without time zone
  language internal;

-- less-equal-greater
create function pg_catalog.timestamp_cmp(timestamp without time zone, timestamp without time zone) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.timestamp_cmp_date(timestamp without time zone, date) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.timestamp_cmp_timestamptz(timestamp without time zone, timestamp with time zone) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.timestamp_eq(timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.timestamp_eq_date(timestamp without time zone, date) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.timestamp_eq_timestamptz(timestamp without time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timestamp_ge(timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timestamp_ge_date(timestamp without time zone, date) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timestamp_ge_timestamptz(timestamp without time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timestamp_gt(timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timestamp_gt_date(timestamp without time zone, date) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timestamp_gt_timestamptz(timestamp without time zone, timestamp with time zone) returns boolean
  language internal;

-- hash
create function pg_catalog.timestamp_hash(timestamp without time zone) returns integer
  language internal;

-- hash
create function pg_catalog.timestamp_hash_extended(timestamp without time zone, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.timestamp_in(cstring, oid, integer) returns timestamp without time zone
  language internal;

-- larger of two
create function pg_catalog.timestamp_larger(timestamp without time zone, timestamp without time zone) returns timestamp without time zone
  language internal;

-- implementation of <= operator
create function pg_catalog.timestamp_le(timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.timestamp_le_date(timestamp without time zone, date) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.timestamp_le_timestamptz(timestamp without time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timestamp_lt(timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timestamp_lt_date(timestamp without time zone, date) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timestamp_lt_timestamptz(timestamp without time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.timestamp_mi(timestamp without time zone, timestamp without time zone) returns interval
  language internal;

-- implementation of - operator
create function pg_catalog.timestamp_mi_interval(timestamp without time zone, interval) returns timestamp without time zone
  language internal;

-- implementation of <> operator
create function pg_catalog.timestamp_ne(timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.timestamp_ne_date(timestamp without time zone, date) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.timestamp_ne_timestamptz(timestamp without time zone, timestamp with time zone) returns boolean
  language internal;

-- I/O
create function pg_catalog.timestamp_out(timestamp without time zone) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.timestamp_pl_interval(timestamp without time zone, interval) returns timestamp without time zone
  language internal;

-- I/O
create function pg_catalog.timestamp_recv(internal, oid, integer) returns timestamp without time zone
  language internal;

-- I/O
create function pg_catalog.timestamp_send(timestamp without time zone) returns bytea
  language internal;

-- skip support
create function pg_catalog.timestamp_skipsupport(internal) returns void
  language internal;

-- smaller of two
create function pg_catalog.timestamp_smaller(timestamp without time zone, timestamp without time zone) returns timestamp without time zone
  language internal;

-- sort support
create function pg_catalog.timestamp_sortsupport(internal) returns void
  language internal;

-- planner support for timestamp length coercion
create function pg_catalog.timestamp_support(internal) returns internal
  language internal;

-- I/O typmod
create function pg_catalog.timestamptypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.timestamptypmodout(integer) returns cstring
  language internal;

-- convert date to timestamp with time zone
create function pg_catalog.timestamptz(date) returns timestamp with time zone
  language internal;

-- convert date and time with time zone to timestamp with time zone
create function pg_catalog.timestamptz(date, time with time zone) returns timestamp with time zone
  language internal;

-- convert date and time to timestamp with time zone
create function pg_catalog.timestamptz(date, time without time zone) returns timestamp with time zone
  language sql;

-- adjust timestamptz precision
create function pg_catalog.timestamptz(timestamp with time zone, integer) returns timestamp with time zone
  language internal;

-- convert timestamp to timestamp with time zone
create function pg_catalog.timestamptz(timestamp without time zone) returns timestamp with time zone
  language internal;

-- less-equal-greater
create function pg_catalog.timestamptz_cmp(timestamp with time zone, timestamp with time zone) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.timestamptz_cmp_date(timestamp with time zone, date) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.timestamptz_cmp_timestamp(timestamp with time zone, timestamp without time zone) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.timestamptz_eq(timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.timestamptz_eq_date(timestamp with time zone, date) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.timestamptz_eq_timestamp(timestamp with time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timestamptz_ge(timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timestamptz_ge_date(timestamp with time zone, date) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timestamptz_ge_timestamp(timestamp with time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timestamptz_gt(timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timestamptz_gt_date(timestamp with time zone, date) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timestamptz_gt_timestamp(timestamp with time zone, timestamp without time zone) returns boolean
  language internal;

-- hash
create function pg_catalog.timestamptz_hash(timestamp with time zone) returns integer
  language internal;

-- hash
create function pg_catalog.timestamptz_hash_extended(timestamp with time zone, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.timestamptz_in(cstring, oid, integer) returns timestamp with time zone
  language internal;

-- larger of two
create function pg_catalog.timestamptz_larger(timestamp with time zone, timestamp with time zone) returns timestamp with time zone
  language internal;

-- implementation of <= operator
create function pg_catalog.timestamptz_le(timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.timestamptz_le_date(timestamp with time zone, date) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.timestamptz_le_timestamp(timestamp with time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timestamptz_lt(timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timestamptz_lt_date(timestamp with time zone, date) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timestamptz_lt_timestamp(timestamp with time zone, timestamp without time zone) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.timestamptz_mi(timestamp with time zone, timestamp with time zone) returns interval
  language internal;

-- implementation of - operator
create function pg_catalog.timestamptz_mi_interval(timestamp with time zone, interval) returns timestamp with time zone
  language internal;

-- implementation of <> operator
create function pg_catalog.timestamptz_ne(timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.timestamptz_ne_date(timestamp with time zone, date) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.timestamptz_ne_timestamp(timestamp with time zone, timestamp without time zone) returns boolean
  language internal;

-- I/O
create function pg_catalog.timestamptz_out(timestamp with time zone) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.timestamptz_pl_interval(timestamp with time zone, interval) returns timestamp with time zone
  language internal;

-- I/O
create function pg_catalog.timestamptz_recv(internal, oid, integer) returns timestamp with time zone
  language internal;

-- I/O
create function pg_catalog.timestamptz_send(timestamp with time zone) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.timestamptz_smaller(timestamp with time zone, timestamp with time zone) returns timestamp with time zone
  language internal;

-- I/O typmod
create function pg_catalog.timestamptztypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.timestamptztypmodout(integer) returns cstring
  language internal;

-- I/O typmod
create function pg_catalog.timetypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.timetypmodout(integer) returns cstring
  language internal;

-- adjust time with time zone precision
create function pg_catalog.timetz(time with time zone, integer) returns time with time zone
  language internal;

-- convert time to time with time zone
create function pg_catalog.timetz(time without time zone) returns time with time zone
  language internal;

-- convert timestamp with time zone to time with time zone
create function pg_catalog.timetz(timestamp with time zone) returns time with time zone
  language internal;

-- less-equal-greater
create function pg_catalog.timetz_cmp(time with time zone, time with time zone) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.timetz_eq(time with time zone, time with time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.timetz_ge(time with time zone, time with time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.timetz_gt(time with time zone, time with time zone) returns boolean
  language internal;

-- hash
create function pg_catalog.timetz_hash(time with time zone) returns integer
  language internal;

-- hash
create function pg_catalog.timetz_hash_extended(time with time zone, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.timetz_in(cstring, oid, integer) returns time with time zone
  language internal;

-- larger of two
create function pg_catalog.timetz_larger(time with time zone, time with time zone) returns time with time zone
  language internal;

-- implementation of <= operator
create function pg_catalog.timetz_le(time with time zone, time with time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.timetz_lt(time with time zone, time with time zone) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.timetz_mi_interval(time with time zone, interval) returns time with time zone
  language internal;

-- implementation of <> operator
create function pg_catalog.timetz_ne(time with time zone, time with time zone) returns boolean
  language internal;

-- I/O
create function pg_catalog.timetz_out(time with time zone) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.timetz_pl_interval(time with time zone, interval) returns time with time zone
  language internal;

-- I/O
create function pg_catalog.timetz_recv(internal, oid, integer) returns time with time zone
  language internal;

-- I/O
create function pg_catalog.timetz_send(time with time zone) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.timetz_smaller(time with time zone, time with time zone) returns time with time zone
  language internal;

-- implementation of + operator
create function pg_catalog.timetzdate_pl(time with time zone, date) returns timestamp with time zone
  language sql;

-- I/O typmod
create function pg_catalog.timetztypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.timetztypmodout(integer) returns cstring
  language internal;

-- adjust time with time zone to new zone
create function pg_catalog.timezone(interval, time with time zone) returns time with time zone
  language internal;

-- adjust timestamp to new time zone
create function pg_catalog.timezone(interval, timestamp with time zone) returns timestamp without time zone
  language internal;

-- adjust timestamp to new time zone
create function pg_catalog.timezone(interval, timestamp without time zone) returns timestamp with time zone
  language internal;

-- adjust time with time zone to new zone
create function pg_catalog.timezone(text, time with time zone) returns time with time zone
  language internal;

-- adjust timestamp to new time zone
create function pg_catalog.timezone(text, timestamp with time zone) returns timestamp without time zone
  language internal;

-- adjust timestamp to new time zone
create function pg_catalog.timezone(text, timestamp without time zone) returns timestamp with time zone
  language internal;

-- adjust time to local time zone
create function pg_catalog.timezone(time with time zone) returns time with time zone
  language internal;

-- adjust timestamp to local time zone
create function pg_catalog.timezone(timestamp with time zone) returns timestamp without time zone
  language internal;

-- adjust timestamp to local time zone
create function pg_catalog.timezone(timestamp without time zone) returns timestamp with time zone
  language internal;

-- encode text from DB encoding to ASCII text
create function pg_catalog.to_ascii(text) returns text
  language internal;

-- encode text from encoding to ASCII text
create function pg_catalog.to_ascii(text, integer) returns text
  language internal;

-- encode text from encoding to ASCII text
create function pg_catalog.to_ascii(text, name) returns text
  language internal;

-- convert int8 number to binary
create function pg_catalog.to_bin(bigint) returns text
  language internal;

-- convert int4 number to binary
create function pg_catalog.to_bin(integer) returns text
  language internal;

-- format int8 to text
create function pg_catalog.to_char(bigint, text) returns text
  language internal;

-- format float8 to text
create function pg_catalog.to_char(double precision, text) returns text
  language internal;

-- format int4 to text
create function pg_catalog.to_char(integer, text) returns text
  language internal;

-- format interval to text
create function pg_catalog.to_char(interval, text) returns text
  language internal;

-- format numeric to text
create function pg_catalog.to_char(numeric, text) returns text
  language internal;

-- format float4 to text
create function pg_catalog.to_char(real, text) returns text
  language internal;

-- format timestamp with time zone to text
create function pg_catalog.to_char(timestamp with time zone, text) returns text
  language internal;

-- format timestamp to text
create function pg_catalog.to_char(timestamp without time zone, text) returns text
  language internal;

-- convert text to date
create function pg_catalog.to_date(text, text) returns date
  language internal;

-- convert int8 number to hex
create function pg_catalog.to_hex(bigint) returns text
  language internal;

-- convert int4 number to hex
create function pg_catalog.to_hex(integer) returns text
  language internal;

-- map input to json
create function pg_catalog.to_json(anyelement) returns json
  language internal;

-- map input to jsonb
create function pg_catalog.to_jsonb(anyelement) returns jsonb
  language internal;

-- convert text to numeric
create function pg_catalog.to_number(text, text) returns numeric
  language internal;

-- convert int8 number to oct
create function pg_catalog.to_oct(bigint) returns text
  language internal;

-- convert int4 number to oct
create function pg_catalog.to_oct(integer) returns text
  language internal;

-- convert classname to regclass
create function pg_catalog.to_regclass(text) returns regclass
  language internal;

-- convert classname to regcollation
create function pg_catalog.to_regcollation(text) returns regcollation
  language internal;

-- convert namespace name to regnamespace
create function pg_catalog.to_regnamespace(text) returns regnamespace
  language internal;

-- convert operator name to regoper
create function pg_catalog.to_regoper(text) returns regoper
  language internal;

-- convert operator name to regoperator
create function pg_catalog.to_regoperator(text) returns regoperator
  language internal;

-- convert proname to regproc
create function pg_catalog.to_regproc(text) returns regproc
  language internal;

-- convert proname to regprocedure
create function pg_catalog.to_regprocedure(text) returns regprocedure
  language internal;

-- convert role name to regrole
create function pg_catalog.to_regrole(text) returns regrole
  language internal;

-- convert type name to regtype
create function pg_catalog.to_regtype(text) returns regtype
  language internal;

-- convert type name to type modifier
create function pg_catalog.to_regtypemod(text) returns integer
  language internal;

-- convert UNIX epoch to timestamptz
create function pg_catalog.to_timestamp(double precision) returns timestamp with time zone
  language internal;

-- convert text to timestamp with time zone
create function pg_catalog.to_timestamp(text, text) returns timestamp with time zone
  language internal;

-- make tsquery
create function pg_catalog.to_tsquery(regconfig, text) returns tsquery
  language internal;

-- make tsquery
create function pg_catalog.to_tsquery(text) returns tsquery
  language internal;

-- transform string values from json to tsvector
create function pg_catalog.to_tsvector(json) returns tsvector
  language internal;

-- transform string values from jsonb to tsvector
create function pg_catalog.to_tsvector(jsonb) returns tsvector
  language internal;

-- transform string values from json to tsvector
create function pg_catalog.to_tsvector(regconfig, json) returns tsvector
  language internal;

-- transform string values from jsonb to tsvector
create function pg_catalog.to_tsvector(regconfig, jsonb) returns tsvector
  language internal;

-- transform to tsvector
create function pg_catalog.to_tsvector(regconfig, text) returns tsvector
  language internal;

-- transform to tsvector
create function pg_catalog.to_tsvector(text) returns tsvector
  language internal;

-- current transaction time
create function pg_catalog.transaction_timestamp() returns timestamp with time zone
  language internal;

-- map a set of characters appearing in string
create function pg_catalog.translate(text, text, text) returns text
  language internal;

-- I/O
create function pg_catalog.trigger_in(cstring) returns trigger
  language internal;

-- I/O
create function pg_catalog.trigger_out(trigger) returns cstring
  language internal;

-- remove last N elements of array
create function pg_catalog.trim_array(anyarray, integer) returns anyarray
  language internal;

-- numeric with minimum scale needed to represent the value
create function pg_catalog.trim_scale(numeric) returns numeric
  language internal;

-- truncate to integer
create function pg_catalog.trunc(double precision) returns double precision
  language internal;

-- MACADDR manufacturer fields
create function pg_catalog.trunc(macaddr) returns macaddr
  language internal;

-- MACADDR8 manufacturer fields
create function pg_catalog.trunc(macaddr8) returns macaddr8
  language internal;

-- value truncated to 'scale' of zero
create function pg_catalog.trunc(numeric) returns numeric
  language sql;

-- value truncated to 'scale'
create function pg_catalog.trunc(numeric, integer) returns numeric
  language internal;

-- debug function for text search configuration
create function pg_catalog.ts_debug(config regconfig, document text, OUT alias text, OUT description text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary regdictionary, OUT lexemes text[]) returns SETOF record
  language sql;

-- debug function for current text search configuration
create function pg_catalog.ts_debug(document text, OUT alias text, OUT description text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary regdictionary, OUT lexemes text[]) returns SETOF record
  language sql;

-- delete lexeme
create function pg_catalog.ts_delete(tsvector, text) returns tsvector
  language internal;

-- delete given lexemes
create function pg_catalog.ts_delete(tsvector, text[]) returns tsvector
  language internal;

-- delete lexemes that do not have one of the given weights
create function pg_catalog.ts_filter(tsvector, "char"[]) returns tsvector
  language internal;

-- generate headline from json
create function pg_catalog.ts_headline(json, tsquery) returns json
  language internal;

-- generate headline from json
create function pg_catalog.ts_headline(json, tsquery, text) returns json
  language internal;

-- generate headline from jsonb
create function pg_catalog.ts_headline(jsonb, tsquery) returns jsonb
  language internal;

-- generate headline from jsonb
create function pg_catalog.ts_headline(jsonb, tsquery, text) returns jsonb
  language internal;

-- generate headline from json
create function pg_catalog.ts_headline(regconfig, json, tsquery) returns json
  language internal;

-- generate headline from json
create function pg_catalog.ts_headline(regconfig, json, tsquery, text) returns json
  language internal;

-- generate headline from jsonb
create function pg_catalog.ts_headline(regconfig, jsonb, tsquery) returns jsonb
  language internal;

-- generate headline from jsonb
create function pg_catalog.ts_headline(regconfig, jsonb, tsquery, text) returns jsonb
  language internal;

-- generate headline
create function pg_catalog.ts_headline(regconfig, text, tsquery) returns text
  language internal;

-- generate headline
create function pg_catalog.ts_headline(regconfig, text, tsquery, text) returns text
  language internal;

-- generate headline
create function pg_catalog.ts_headline(text, tsquery) returns text
  language internal;

-- generate headline
create function pg_catalog.ts_headline(text, tsquery, text) returns text
  language internal;

-- normalize one word by dictionary
create function pg_catalog.ts_lexize(regdictionary, text) returns text[]
  language internal;

-- implementation of @@ operator
create function pg_catalog.ts_match_qv(tsquery, tsvector) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.ts_match_tq(text, tsquery) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.ts_match_tt(text, text) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.ts_match_vq(tsvector, tsquery) returns boolean
  language internal;

-- parse text to tokens
create function pg_catalog.ts_parse(parser_name text, txt text, OUT tokid integer, OUT token text) returns SETOF record
  language internal;

-- parse text to tokens
create function pg_catalog.ts_parse(parser_oid oid, txt text, OUT tokid integer, OUT token text) returns SETOF record
  language internal;

-- relevance
create function pg_catalog.ts_rank(real[], tsvector, tsquery) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank(real[], tsvector, tsquery, integer) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank(tsvector, tsquery) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank(tsvector, tsquery, integer) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank_cd(real[], tsvector, tsquery) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank_cd(real[], tsvector, tsquery, integer) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank_cd(tsvector, tsquery) returns real
  language internal;

-- relevance
create function pg_catalog.ts_rank_cd(tsvector, tsquery, integer) returns real
  language internal;

-- rewrite tsquery
create function pg_catalog.ts_rewrite(tsquery, text) returns tsquery
  language internal;

-- rewrite tsquery
create function pg_catalog.ts_rewrite(tsquery, tsquery, tsquery) returns tsquery
  language internal;

-- statistics of tsvector column
create function pg_catalog.ts_stat(query text, OUT word text, OUT ndoc integer, OUT nentry integer) returns SETOF record
  language internal;

-- statistics of tsvector column
create function pg_catalog.ts_stat(query text, weights text, OUT word text, OUT ndoc integer, OUT nentry integer) returns SETOF record
  language internal;

-- get parser's token types
create function pg_catalog.ts_token_type(parser_name text, OUT tokid integer, OUT alias text, OUT description text) returns SETOF record
  language internal;

-- get parser's token types
create function pg_catalog.ts_token_type(parser_oid oid, OUT tokid integer, OUT alias text, OUT description text) returns SETOF record
  language internal;

-- tsvector typanalyze
create function pg_catalog.ts_typanalyze(internal) returns boolean
  language internal;

-- I/O
create function pg_catalog.tsm_handler_in(cstring) returns tsm_handler
  language internal;

-- I/O
create function pg_catalog.tsm_handler_out(tsm_handler) returns cstring
  language internal;

-- join selectivity of tsvector @@ tsquery
create function pg_catalog.tsmatchjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of tsvector @@ tsquery
create function pg_catalog.tsmatchsel(internal, oid, internal, integer) returns double precision
  language internal;

-- tsmultirange constructor
create function pg_catalog.tsmultirange() returns tsmultirange
  language internal;

-- tsmultirange constructor
create function pg_catalog.tsmultirange(tsrange) returns tsmultirange
  language internal;

-- tsmultirange constructor
create function pg_catalog.tsmultirange(VARIADIC tsrange[]) returns tsmultirange
  language internal;

-- implementation of <@ operator
create function pg_catalog.tsq_mcontained(tsquery, tsquery) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.tsq_mcontains(tsquery, tsquery) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.tsquery_and(tsquery, tsquery) returns tsquery
  language internal;

-- less-equal-greater
create function pg_catalog.tsquery_cmp(tsquery, tsquery) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.tsquery_eq(tsquery, tsquery) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.tsquery_ge(tsquery, tsquery) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.tsquery_gt(tsquery, tsquery) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.tsquery_le(tsquery, tsquery) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.tsquery_lt(tsquery, tsquery) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.tsquery_ne(tsquery, tsquery) returns boolean
  language internal;

-- implementation of !! operator
create function pg_catalog.tsquery_not(tsquery) returns tsquery
  language internal;

-- implementation of || operator
create function pg_catalog.tsquery_or(tsquery, tsquery) returns tsquery
  language internal;

-- implementation of <-> operator
create function pg_catalog.tsquery_phrase(tsquery, tsquery) returns tsquery
  language internal;

-- phrase-concatenate with distance
create function pg_catalog.tsquery_phrase(tsquery, tsquery, integer) returns tsquery
  language internal;

-- I/O
create function pg_catalog.tsqueryin(cstring) returns tsquery
  language internal;

-- I/O
create function pg_catalog.tsqueryout(tsquery) returns cstring
  language internal;

-- I/O
create function pg_catalog.tsqueryrecv(internal) returns tsquery
  language internal;

-- I/O
create function pg_catalog.tsquerysend(tsquery) returns bytea
  language internal;

-- tsrange constructor
create function pg_catalog.tsrange(timestamp without time zone, timestamp without time zone) returns tsrange
  language internal;

-- tsrange constructor
create function pg_catalog.tsrange(timestamp without time zone, timestamp without time zone, text) returns tsrange
  language internal;

-- float8 difference of two timestamp values
create function pg_catalog.tsrange_subdiff(timestamp without time zone, timestamp without time zone) returns double precision
  language internal;

-- tstzmultirange constructor
create function pg_catalog.tstzmultirange() returns tstzmultirange
  language internal;

-- tstzmultirange constructor
create function pg_catalog.tstzmultirange(tstzrange) returns tstzmultirange
  language internal;

-- tstzmultirange constructor
create function pg_catalog.tstzmultirange(VARIADIC tstzrange[]) returns tstzmultirange
  language internal;

-- tstzrange constructor
create function pg_catalog.tstzrange(timestamp with time zone, timestamp with time zone) returns tstzrange
  language internal;

-- tstzrange constructor
create function pg_catalog.tstzrange(timestamp with time zone, timestamp with time zone, text) returns tstzrange
  language internal;

-- float8 difference of two timestamp with time zone values
create function pg_catalog.tstzrange_subdiff(timestamp with time zone, timestamp with time zone) returns double precision
  language internal;

-- less-equal-greater
create function pg_catalog.tsvector_cmp(tsvector, tsvector) returns integer
  language internal;

-- implementation of || operator
create function pg_catalog.tsvector_concat(tsvector, tsvector) returns tsvector
  language internal;

-- implementation of = operator
create function pg_catalog.tsvector_eq(tsvector, tsvector) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.tsvector_ge(tsvector, tsvector) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.tsvector_gt(tsvector, tsvector) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.tsvector_le(tsvector, tsvector) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.tsvector_lt(tsvector, tsvector) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.tsvector_ne(tsvector, tsvector) returns boolean
  language internal;

-- convert tsvector to array of lexemes
create function pg_catalog.tsvector_to_array(tsvector) returns text[]
  language internal;

-- trigger for automatic update of tsvector column
create function pg_catalog.tsvector_update_trigger() returns trigger
  language internal;

-- trigger for automatic update of tsvector column
create function pg_catalog.tsvector_update_trigger_column() returns trigger
  language internal;

-- I/O
create function pg_catalog.tsvectorin(cstring) returns tsvector
  language internal;

-- I/O
create function pg_catalog.tsvectorout(tsvector) returns cstring
  language internal;

-- I/O
create function pg_catalog.tsvectorrecv(internal) returns tsvector
  language internal;

-- I/O
create function pg_catalog.tsvectorsend(tsvector) returns bytea
  language internal;

-- get current transaction ID
create function pg_catalog.txid_current() returns bigint
  language internal;

-- get current transaction ID
create function pg_catalog.txid_current_if_assigned() returns bigint
  language internal;

-- get current snapshot
create function pg_catalog.txid_current_snapshot() returns txid_snapshot
  language internal;

-- I/O
create function pg_catalog.txid_snapshot_in(cstring) returns txid_snapshot
  language internal;

-- I/O
create function pg_catalog.txid_snapshot_out(txid_snapshot) returns cstring
  language internal;

-- I/O
create function pg_catalog.txid_snapshot_recv(internal) returns txid_snapshot
  language internal;

-- I/O
create function pg_catalog.txid_snapshot_send(txid_snapshot) returns bytea
  language internal;

-- get set of in-progress txids in snapshot
create function pg_catalog.txid_snapshot_xip(txid_snapshot) returns SETOF bigint
  language internal;

-- get xmax of snapshot
create function pg_catalog.txid_snapshot_xmax(txid_snapshot) returns bigint
  language internal;

-- get xmin of snapshot
create function pg_catalog.txid_snapshot_xmin(txid_snapshot) returns bigint
  language internal;

-- commit status of transaction
create function pg_catalog.txid_status(bigint) returns text
  language internal;

-- is txid visible in snapshot?
create function pg_catalog.txid_visible_in_snapshot(bigint, txid_snapshot) returns boolean
  language internal;

-- internal conversion function for UHC to UTF8
create function pg_catalog.uhc_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- check valid Unicode
create function pg_catalog.unicode_assigned(text) returns boolean
  language internal;

-- Unicode version used by Postgres
create function pg_catalog.unicode_version() returns text
  language internal;

-- deferred UNIQUE constraint check
create function pg_catalog.unique_key_recheck() returns trigger
  language internal;

-- unescape Unicode characters
create function pg_catalog.unistr(text) returns text
  language internal;

-- I/O
create function pg_catalog.unknownin(cstring) returns unknown
  language internal;

-- I/O
create function pg_catalog.unknownout(unknown) returns cstring
  language internal;

-- I/O
create function pg_catalog.unknownrecv(internal) returns unknown
  language internal;

-- I/O
create function pg_catalog.unknownsend(unknown) returns bytea
  language internal;

-- expand array to set of rows
create function pg_catalog.unnest(anyarray) returns SETOF anyelement
  language internal;

-- expand multirange to set of ranges
create function pg_catalog.unnest(anymultirange) returns SETOF anyrange
  language internal;

-- expand tsvector to set of rows
create function pg_catalog.unnest(tsvector tsvector, OUT lexeme text, OUT positions smallint[], OUT weights text[]) returns SETOF record
  language internal;

-- upper bound of multirange
create function pg_catalog.upper(anymultirange) returns anyelement
  language internal;

-- upper bound of range
create function pg_catalog.upper(anyrange) returns anyelement
  language internal;

-- uppercase
create function pg_catalog.upper(text) returns text
  language internal;

-- is the multirange's upper bound inclusive?
create function pg_catalog.upper_inc(anymultirange) returns boolean
  language internal;

-- is the range's upper bound inclusive?
create function pg_catalog.upper_inc(anyrange) returns boolean
  language internal;

-- is the multirange's upper bound infinite?
create function pg_catalog.upper_inf(anymultirange) returns boolean
  language internal;

-- is the range's upper bound infinite?
create function pg_catalog.upper_inf(anyrange) returns boolean
  language internal;

-- internal conversion function for UTF8 to BIG5
create function pg_catalog.utf8_to_big5(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to EUC_CN
create function pg_catalog.utf8_to_euc_cn(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to EUC_JIS_2004
create function pg_catalog.utf8_to_euc_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to EUC_JP
create function pg_catalog.utf8_to_euc_jp(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to EUC_KR
create function pg_catalog.utf8_to_euc_kr(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to EUC_TW
create function pg_catalog.utf8_to_euc_tw(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to GB18030
create function pg_catalog.utf8_to_gb18030(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to GBK
create function pg_catalog.utf8_to_gbk(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to ISO-8859 2-16
create function pg_catalog.utf8_to_iso8859(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to LATIN1
create function pg_catalog.utf8_to_iso8859_1(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to JOHAB
create function pg_catalog.utf8_to_johab(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to KOI8R
create function pg_catalog.utf8_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to KOI8U
create function pg_catalog.utf8_to_koi8u(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to SHIFT_JIS_2004
create function pg_catalog.utf8_to_shift_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to SJIS
create function pg_catalog.utf8_to_sjis(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to UHC
create function pg_catalog.utf8_to_uhc(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for UTF8 to WIN
create function pg_catalog.utf8_to_win(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- less-equal-greater
create function pg_catalog.uuid_cmp(uuid, uuid) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.uuid_eq(uuid, uuid) returns boolean
  language internal;

-- extract timestamp from UUID
create function pg_catalog.uuid_extract_timestamp(uuid) returns timestamp with time zone
  language internal;

-- extract version from RFC 9562 UUID
create function pg_catalog.uuid_extract_version(uuid) returns smallint
  language internal;

-- implementation of >= operator
create function pg_catalog.uuid_ge(uuid, uuid) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.uuid_gt(uuid, uuid) returns boolean
  language internal;

-- hash
create function pg_catalog.uuid_hash(uuid) returns integer
  language internal;

-- hash
create function pg_catalog.uuid_hash_extended(uuid, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.uuid_in(cstring) returns uuid
  language internal;

-- implementation of <= operator
create function pg_catalog.uuid_le(uuid, uuid) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.uuid_lt(uuid, uuid) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.uuid_ne(uuid, uuid) returns boolean
  language internal;

-- I/O
create function pg_catalog.uuid_out(uuid) returns cstring
  language internal;

-- I/O
create function pg_catalog.uuid_recv(internal) returns uuid
  language internal;

-- I/O
create function pg_catalog.uuid_send(uuid) returns bytea
  language internal;

-- skip support
create function pg_catalog.uuid_skipsupport(internal) returns void
  language internal;

-- sort support
create function pg_catalog.uuid_sortsupport(internal) returns void
  language internal;

-- generate UUID version 4
create function pg_catalog.uuidv4() returns uuid
  language internal;

-- generate UUID version 7
create function pg_catalog.uuidv7() returns uuid
  language internal;

-- generate UUID version 7 with a timestamp shifted by specified interval
create function pg_catalog.uuidv7(shift interval) returns uuid
  language internal;

-- population variance of bigint input values (square of the population standard deviation)
create aggregate pg_catalog.var_pop(bigint) (
  sfunc = int8_accum,
  stype = internal,
  finalfunc = numeric_var_pop,
  combinefunc = numeric_combine
);

-- population variance of float8 input values (square of the population standard deviation)
create aggregate pg_catalog.var_pop(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_var_pop,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- population variance of integer input values (square of the population standard deviation)
create aggregate pg_catalog.var_pop(integer) (
  sfunc = int4_accum,
  stype = internal,
  finalfunc = numeric_poly_var_pop,
  combinefunc = numeric_poly_combine
);

-- population variance of numeric input values (square of the population standard deviation)
create aggregate pg_catalog.var_pop(numeric) (
  sfunc = numeric_accum,
  stype = internal,
  finalfunc = numeric_var_pop,
  combinefunc = numeric_combine
);

-- population variance of float4 input values (square of the population standard deviation)
create aggregate pg_catalog.var_pop(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_var_pop,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- population variance of smallint input values (square of the population standard deviation)
create aggregate pg_catalog.var_pop(smallint) (
  sfunc = int2_accum,
  stype = internal,
  finalfunc = numeric_poly_var_pop,
  combinefunc = numeric_poly_combine
);

-- sample variance of bigint input values (square of the sample standard deviation)
create aggregate pg_catalog.var_samp(bigint) (
  sfunc = int8_accum,
  stype = internal,
  finalfunc = numeric_var_samp,
  combinefunc = numeric_combine
);

-- sample variance of float8 input values (square of the sample standard deviation)
create aggregate pg_catalog.var_samp(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_var_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- sample variance of integer input values (square of the sample standard deviation)
create aggregate pg_catalog.var_samp(integer) (
  sfunc = int4_accum,
  stype = internal,
  finalfunc = numeric_poly_var_samp,
  combinefunc = numeric_poly_combine
);

-- sample variance of numeric input values (square of the sample standard deviation)
create aggregate pg_catalog.var_samp(numeric) (
  sfunc = numeric_accum,
  stype = internal,
  finalfunc = numeric_var_samp,
  combinefunc = numeric_combine
);

-- sample variance of float4 input values (square of the sample standard deviation)
create aggregate pg_catalog.var_samp(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_var_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- sample variance of smallint input values (square of the sample standard deviation)
create aggregate pg_catalog.var_samp(smallint) (
  sfunc = int2_accum,
  stype = internal,
  finalfunc = numeric_poly_var_samp,
  combinefunc = numeric_poly_combine
);

-- adjust varbit() to typmod length
create function pg_catalog.varbit(bit varying, integer, boolean) returns bit varying
  language internal;

-- I/O
create function pg_catalog.varbit_in(cstring, oid, integer) returns bit varying
  language internal;

-- I/O
create function pg_catalog.varbit_out(bit varying) returns cstring
  language internal;

-- I/O
create function pg_catalog.varbit_recv(internal, oid, integer) returns bit varying
  language internal;

-- I/O
create function pg_catalog.varbit_send(bit varying) returns bytea
  language internal;

-- planner support for varbit length coercion
create function pg_catalog.varbit_support(internal) returns internal
  language internal;

-- less-equal-greater
create function pg_catalog.varbitcmp(bit varying, bit varying) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.varbiteq(bit varying, bit varying) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.varbitge(bit varying, bit varying) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.varbitgt(bit varying, bit varying) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.varbitle(bit varying, bit varying) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.varbitlt(bit varying, bit varying) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.varbitne(bit varying, bit varying) returns boolean
  language internal;

-- I/O typmod
create function pg_catalog.varbittypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.varbittypmodout(integer) returns cstring
  language internal;

-- adjust varchar() to typmod length
create function pg_catalog.varchar(character varying, integer, boolean) returns character varying
  language internal;

-- convert name to varchar
create function pg_catalog.varchar(name) returns character varying
  language internal;

-- planner support for varchar length coercion
create function pg_catalog.varchar_support(internal) returns internal
  language internal;

-- I/O
create function pg_catalog.varcharin(cstring, oid, integer) returns character varying
  language internal;

-- I/O
create function pg_catalog.varcharout(character varying) returns cstring
  language internal;

-- I/O
create function pg_catalog.varcharrecv(internal, oid, integer) returns character varying
  language internal;

-- I/O
create function pg_catalog.varcharsend(character varying) returns bytea
  language internal;

-- I/O typmod
create function pg_catalog.varchartypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.varchartypmodout(integer) returns cstring
  language internal;

-- historical alias for var_samp
create aggregate pg_catalog.variance(bigint) (
  sfunc = int8_accum,
  stype = internal,
  finalfunc = numeric_var_samp,
  combinefunc = numeric_combine
);

-- historical alias for var_samp
create aggregate pg_catalog.variance(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_var_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- historical alias for var_samp
create aggregate pg_catalog.variance(integer) (
  sfunc = int4_accum,
  stype = internal,
  finalfunc = numeric_poly_var_samp,
  combinefunc = numeric_poly_combine
);

-- historical alias for var_samp
create aggregate pg_catalog.variance(numeric) (
  sfunc = numeric_accum,
  stype = internal,
  finalfunc = numeric_var_samp,
  combinefunc = numeric_combine
);

-- historical alias for var_samp
create aggregate pg_catalog.variance(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_var_samp,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- historical alias for var_samp
create aggregate pg_catalog.variance(smallint) (
  sfunc = int2_accum,
  stype = internal,
  finalfunc = numeric_poly_var_samp,
  combinefunc = numeric_poly_combine
);

-- PostgreSQL version string
create function pg_catalog.version() returns text
  language internal;

-- I/O
create function pg_catalog.void_in(cstring) returns void
  language internal;

-- I/O
create function pg_catalog.void_out(void) returns cstring
  language internal;

-- I/O
create function pg_catalog.void_recv(internal) returns void
  language internal;

-- I/O
create function pg_catalog.void_send(void) returns bytea
  language internal;

-- transform to tsquery
create function pg_catalog.websearch_to_tsquery(regconfig, text) returns tsquery
  language internal;

-- transform to tsquery
create function pg_catalog.websearch_to_tsquery(text) returns tsquery
  language internal;

-- box width
create function pg_catalog.width(box) returns double precision
  language internal;

-- bucket number of operand given a sorted array of bucket lower bounds
create function pg_catalog.width_bucket(anycompatible, anycompatiblearray) returns integer
  language internal;

-- bucket number of operand in equal-width histogram
create function pg_catalog.width_bucket(double precision, double precision, double precision, integer) returns integer
  language internal;

-- bucket number of operand in equal-width histogram
create function pg_catalog.width_bucket(numeric, numeric, numeric, integer) returns integer
  language internal;

-- internal conversion function for WIN1250 to LATIN2
create function pg_catalog.win1250_to_latin2(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN1250 to MULE_INTERNAL
create function pg_catalog.win1250_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN1251 to ISO-8859-5
create function pg_catalog.win1251_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN1251 to KOI8R
create function pg_catalog.win1251_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN1251 to MULE_INTERNAL
create function pg_catalog.win1251_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN1251 to WIN866
create function pg_catalog.win1251_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN866 to ISO-8859-5
create function pg_catalog.win866_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN866 to KOI8R
create function pg_catalog.win866_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN866 to MULE_INTERNAL
create function pg_catalog.win866_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN866 to WIN1251
create function pg_catalog.win866_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for WIN to UTF8
create function pg_catalog.win_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- planner support for cume_dist
create function pg_catalog.window_cume_dist_support(internal) returns internal
  language internal;

-- planner support for dense_rank
create function pg_catalog.window_dense_rank_support(internal) returns internal
  language internal;

-- planner support for ntile
create function pg_catalog.window_ntile_support(internal) returns internal
  language internal;

-- planner support for percent_rank
create function pg_catalog.window_percent_rank_support(internal) returns internal
  language internal;

-- planner support for rank
create function pg_catalog.window_rank_support(internal) returns internal
  language internal;

-- planner support for row_number
create function pg_catalog.window_row_number_support(internal) returns internal
  language internal;

-- convert xid8 to xid
create function pg_catalog.xid(xid8) returns xid
  language internal;

-- larger of two
create function pg_catalog.xid8_larger(xid8, xid8) returns xid8
  language internal;

-- smaller of two
create function pg_catalog.xid8_smaller(xid8, xid8) returns xid8
  language internal;

-- less-equal-greater
create function pg_catalog.xid8cmp(xid8, xid8) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.xid8eq(xid8, xid8) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.xid8ge(xid8, xid8) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.xid8gt(xid8, xid8) returns boolean
  language internal;

-- I/O
create function pg_catalog.xid8in(cstring) returns xid8
  language internal;

-- implementation of <= operator
create function pg_catalog.xid8le(xid8, xid8) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.xid8lt(xid8, xid8) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.xid8ne(xid8, xid8) returns boolean
  language internal;

-- I/O
create function pg_catalog.xid8out(xid8) returns cstring
  language internal;

-- I/O
create function pg_catalog.xid8recv(internal) returns xid8
  language internal;

-- I/O
create function pg_catalog.xid8send(xid8) returns bytea
  language internal;

-- implementation of = operator
create function pg_catalog.xideq(xid, xid) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.xideqint4(xid, integer) returns boolean
  language internal;

-- I/O
create function pg_catalog.xidin(cstring) returns xid
  language internal;

-- implementation of <> operator
create function pg_catalog.xidneq(xid, xid) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.xidneqint4(xid, integer) returns boolean
  language internal;

-- I/O
create function pg_catalog.xidout(xid) returns cstring
  language internal;

-- I/O
create function pg_catalog.xidrecv(internal) returns xid
  language internal;

-- I/O
create function pg_catalog.xidsend(xid) returns bytea
  language internal;

-- perform a non-validating parse of a character string to produce an XML value
create function pg_catalog.xml(text) returns xml
  language internal;

-- I/O
create function pg_catalog.xml_in(cstring) returns xml
  language internal;

-- determine if a string is well formed XML
create function pg_catalog.xml_is_well_formed(text) returns boolean
  language internal;

-- determine if a string is well formed XML content
create function pg_catalog.xml_is_well_formed_content(text) returns boolean
  language internal;

-- determine if a string is well formed XML document
create function pg_catalog.xml_is_well_formed_document(text) returns boolean
  language internal;

-- I/O
create function pg_catalog.xml_out(xml) returns cstring
  language internal;

-- I/O
create function pg_catalog.xml_recv(internal) returns xml
  language internal;

-- I/O
create function pg_catalog.xml_send(xml) returns bytea
  language internal;

-- concatenate XML values
create aggregate pg_catalog.xmlagg(xml) (
  sfunc = xmlconcat2,
  stype = xml
);

-- generate XML comment
create function pg_catalog.xmlcomment(text) returns xml
  language internal;

-- aggregate transition function
create function pg_catalog.xmlconcat2(xml, xml) returns xml
  language internal;

-- test XML value against XPath expression
create function pg_catalog.xmlexists(text, xml) returns boolean
  language internal;

-- generate XML text node
create function pg_catalog.xmltext(text) returns xml
  language internal;

-- validate an XML value
create function pg_catalog.xmlvalidate(xml, text) returns boolean
  language internal;

-- evaluate XPath expression
create function pg_catalog.xpath(text, xml) returns xml[]
  language sql;

-- evaluate XPath expression, with namespaces support
create function pg_catalog.xpath(text, xml, text[]) returns xml[]
  language internal;

-- test XML value against XPath expression
create function pg_catalog.xpath_exists(text, xml) returns boolean
  language sql;

-- test XML value against XPath expression, with namespace support
create function pg_catalog.xpath_exists(text, xml, text[]) returns boolean
  language internal;

-- NOT tsquery
create operator pg_catalog.!! (
  rightarg = tsquery,
  function = pg_catalog.tsquery_not
);

-- does not match regular expression, case-sensitive
create operator pg_catalog.!~ (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharregexne
);

-- does not match regular expression, case-sensitive
create operator pg_catalog.!~ (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameregexne
);

-- does not match regular expression, case-sensitive
create operator pg_catalog.!~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.textregexne
);

-- does not match regular expression, case-insensitive
create operator pg_catalog.!~* (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharicregexne
);

-- does not match regular expression, case-insensitive
create operator pg_catalog.!~* (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameicregexne
);

-- does not match regular expression, case-insensitive
create operator pg_catalog.!~* (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.texticregexne
);

-- does not match LIKE expression
create operator pg_catalog.!~~ (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteanlike
);

-- does not match LIKE expression
create operator pg_catalog.!~~ (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharnlike
);

-- does not match LIKE expression
create operator pg_catalog.!~~ (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.namenlike
);

-- does not match LIKE expression
create operator pg_catalog.!~~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.textnlike
);

-- does not match LIKE expression, case-insensitive
create operator pg_catalog.!~~* (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharicnlike
);

-- does not match LIKE expression, case-insensitive
create operator pg_catalog.!~~* (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameicnlike
);

-- does not match LIKE expression, case-insensitive
create operator pg_catalog.!~~* (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.texticnlike
);

-- number of points
create operator pg_catalog.# (
  rightarg = path,
  function = pg_catalog.path_npoints
);

-- number of points
create operator pg_catalog.# (
  rightarg = polygon,
  function = pg_catalog.poly_npoints
);

-- bitwise exclusive or
create operator pg_catalog.# (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8xor
);

-- bitwise exclusive or
create operator pg_catalog.# (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitxor
);

-- box intersection
create operator pg_catalog.# (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_intersect
);

-- bitwise exclusive or
create operator pg_catalog.# (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4xor
);

-- intersection point
create operator pg_catalog.# (
  leftarg = line,
  rightarg = line,
  function = pg_catalog.line_interpt
);

-- intersection point
create operator pg_catalog.# (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_interpt
);

-- bitwise exclusive or
create operator pg_catalog.# (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2xor
);

-- closest point to A on B
create operator pg_catalog.## (
  leftarg = line,
  rightarg = lseg,
  function = pg_catalog.close_ls
);

-- closest point to A on B
create operator pg_catalog.## (
  leftarg = lseg,
  rightarg = box,
  function = pg_catalog.close_sb
);

-- closest point to A on B
create operator pg_catalog.## (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.close_lseg
);

-- closest point to A on B
create operator pg_catalog.## (
  leftarg = point,
  rightarg = box,
  function = pg_catalog.close_pb
);

-- closest point to A on B
create operator pg_catalog.## (
  leftarg = point,
  rightarg = line,
  function = pg_catalog.close_pl
);

-- closest point to A on B
create operator pg_catalog.## (
  leftarg = point,
  rightarg = lseg,
  function = pg_catalog.close_ps
);

-- delete path
create operator pg_catalog.#- (
  leftarg = jsonb,
  rightarg = text[],
  function = pg_catalog.jsonb_delete_path
);

-- get value from json with path elements
create operator pg_catalog.#> (
  leftarg = json,
  rightarg = text[],
  function = pg_catalog.json_extract_path
);

-- get value from jsonb with path elements
create operator pg_catalog.#> (
  leftarg = jsonb,
  rightarg = text[],
  function = pg_catalog.jsonb_extract_path
);

-- get value from json as text with path elements
create operator pg_catalog.#>> (
  leftarg = json,
  rightarg = text[],
  function = pg_catalog.json_extract_path_text
);

-- get value from jsonb as text with path elements
create operator pg_catalog.#>> (
  leftarg = jsonb,
  rightarg = text[],
  function = pg_catalog.jsonb_extract_path_text
);

-- modulus
create operator pg_catalog.% (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8mod
);

-- modulus
create operator pg_catalog.% (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4mod
);

-- modulus
create operator pg_catalog.% (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_mod
);

-- modulus
create operator pg_catalog.% (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2mod
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8and
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitand
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.inetand
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4and
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_and
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_and
);

-- bitwise and
create operator pg_catalog.& (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2and
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.arrayoverlap
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_overlaps_multirange
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_overlaps_range
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_overlaps_multirange
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_overlaps
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_overlap
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_overlap
);

-- overlaps (is subnet or supernet)
create operator pg_catalog.&& (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_overlap
);

-- overlaps
create operator pg_catalog.&& (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_overlap
);

-- AND-concatenate
create operator pg_catalog.&& (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_and
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_overleft_multirange
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_overleft_range
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_overleft_multirange
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_overleft
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_overleft
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_overleft
);

-- overlaps or is left of
create operator pg_catalog.&< (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_overleft
);

-- overlaps or is below
create operator pg_catalog.&<| (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_overbelow
);

-- overlaps or is below
create operator pg_catalog.&<| (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_overbelow
);

-- overlaps or is below
create operator pg_catalog.&<| (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_overbelow
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_overright_multirange
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_overright_range
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_overright_multirange
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_overright
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_overright
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_overright
);

-- overlaps or is right of
create operator pg_catalog.&> (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_overright
);

-- multirange intersect
create operator pg_catalog.* (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_intersect
);

-- range intersection
create operator pg_catalog.* (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_intersect
);

-- multiply
create operator pg_catalog.* (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = bigint,
  rightarg = money,
  function = pg_catalog.int8_mul_cash
);

-- multiply
create operator pg_catalog.* (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82mul
);

-- multiply box by point (scale)
create operator pg_catalog.* (
  leftarg = box,
  rightarg = point,
  function = pg_catalog.box_mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = circle,
  rightarg = point,
  function = pg_catalog.circle_mul_pt
);

-- multiply
create operator pg_catalog.* (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = double precision,
  rightarg = interval,
  function = pg_catalog.mul_d_interval
);

-- multiply
create operator pg_catalog.* (
  leftarg = double precision,
  rightarg = money,
  function = pg_catalog.flt8_mul_cash
);

-- multiply
create operator pg_catalog.* (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = integer,
  rightarg = money,
  function = pg_catalog.int4_mul_cash
);

-- multiply
create operator pg_catalog.* (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = interval,
  rightarg = double precision,
  function = pg_catalog.interval_mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = money,
  rightarg = bigint,
  function = pg_catalog.cash_mul_int8
);

-- multiply
create operator pg_catalog.* (
  leftarg = money,
  rightarg = double precision,
  function = pg_catalog.cash_mul_flt8
);

-- multiply
create operator pg_catalog.* (
  leftarg = money,
  rightarg = integer,
  function = pg_catalog.cash_mul_int4
);

-- multiply
create operator pg_catalog.* (
  leftarg = money,
  rightarg = real,
  function = pg_catalog.cash_mul_flt4
);

-- multiply
create operator pg_catalog.* (
  leftarg = money,
  rightarg = smallint,
  function = pg_catalog.cash_mul_int2
);

-- multiply
create operator pg_catalog.* (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_mul
);

-- multiply (rotate/scale path)
create operator pg_catalog.* (
  leftarg = path,
  rightarg = point,
  function = pg_catalog.path_mul_pt
);

-- multiply points (scale/rotate)
create operator pg_catalog.* (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = real,
  rightarg = money,
  function = pg_catalog.flt4_mul_cash
);

-- multiply
create operator pg_catalog.* (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24mul
);

-- multiply
create operator pg_catalog.* (
  leftarg = smallint,
  rightarg = money,
  function = pg_catalog.int2_mul_cash
);

-- multiply
create operator pg_catalog.* (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2mul
);

-- less than
create operator pg_catalog.*< (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_image_lt
);

-- less than or equal
create operator pg_catalog.*<= (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_image_le
);

-- not identical
create operator pg_catalog.*<> (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_image_ne
);

-- identical
create operator pg_catalog.*= (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_image_eq
);

-- greater than
create operator pg_catalog.*> (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_image_gt
);

-- greater than or equal
create operator pg_catalog.*>= (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_image_ge
);

-- unary plus
create operator pg_catalog.+ (
  rightarg = bigint,
  function = pg_catalog.int8up
);

-- unary plus
create operator pg_catalog.+ (
  rightarg = double precision,
  function = pg_catalog.float8up
);

-- unary plus
create operator pg_catalog.+ (
  rightarg = integer,
  function = pg_catalog.int4up
);

-- unary plus
create operator pg_catalog.+ (
  rightarg = numeric,
  function = pg_catalog.numeric_uplus
);

-- unary plus
create operator pg_catalog.+ (
  rightarg = real,
  function = pg_catalog.float4up
);

-- unary plus
create operator pg_catalog.+ (
  rightarg = smallint,
  function = pg_catalog.int2up
);

-- add/update ACL item
create operator pg_catalog.+ (
  leftarg = aclitem[],
  rightarg = aclitem,
  function = pg_catalog.aclinsert
);

-- multirange union
create operator pg_catalog.+ (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_union
);

-- range union
create operator pg_catalog.+ (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_union
);

-- add
create operator pg_catalog.+ (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8pl
);

-- add
create operator pg_catalog.+ (
  leftarg = bigint,
  rightarg = inet,
  function = pg_catalog.int8pl_inet
);

-- add
create operator pg_catalog.+ (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84pl
);

-- add
create operator pg_catalog.+ (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82pl
);

-- add point to box (translate)
create operator pg_catalog.+ (
  leftarg = box,
  rightarg = point,
  function = pg_catalog.box_add
);

-- add
create operator pg_catalog.+ (
  leftarg = circle,
  rightarg = point,
  function = pg_catalog.circle_add_pt
);

-- add
create operator pg_catalog.+ (
  leftarg = date,
  rightarg = integer,
  function = pg_catalog.date_pli
);

-- add
create operator pg_catalog.+ (
  leftarg = date,
  rightarg = interval,
  function = pg_catalog.date_pl_interval
);

-- convert date and time with time zone to timestamp with time zone
create operator pg_catalog.+ (
  leftarg = date,
  rightarg = time with time zone,
  function = pg_catalog.datetimetz_pl
);

-- convert date and time to timestamp
create operator pg_catalog.+ (
  leftarg = date,
  rightarg = time without time zone,
  function = pg_catalog.datetime_pl
);

-- add
create operator pg_catalog.+ (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8pl
);

-- add
create operator pg_catalog.+ (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84pl
);

-- add
create operator pg_catalog.+ (
  leftarg = inet,
  rightarg = bigint,
  function = pg_catalog.inetpl
);

-- add
create operator pg_catalog.+ (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48pl
);

-- add
create operator pg_catalog.+ (
  leftarg = integer,
  rightarg = date,
  function = pg_catalog.integer_pl_date
);

-- add
create operator pg_catalog.+ (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4pl
);

-- add
create operator pg_catalog.+ (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42pl
);

-- add
create operator pg_catalog.+ (
  leftarg = interval,
  rightarg = date,
  function = pg_catalog.interval_pl_date
);

-- add
create operator pg_catalog.+ (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_pl
);

-- add
create operator pg_catalog.+ (
  leftarg = interval,
  rightarg = time with time zone,
  function = pg_catalog.interval_pl_timetz
);

-- add
create operator pg_catalog.+ (
  leftarg = interval,
  rightarg = time without time zone,
  function = pg_catalog.interval_pl_time
);

-- add
create operator pg_catalog.+ (
  leftarg = interval,
  rightarg = timestamp with time zone,
  function = pg_catalog.interval_pl_timestamptz
);

-- add
create operator pg_catalog.+ (
  leftarg = interval,
  rightarg = timestamp without time zone,
  function = pg_catalog.interval_pl_timestamp
);

-- add
create operator pg_catalog.+ (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_pl
);

-- add
create operator pg_catalog.+ (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_add
);

-- add
create operator pg_catalog.+ (
  leftarg = numeric,
  rightarg = pg_lsn,
  function = pg_catalog.numeric_pl_pg_lsn
);

-- concatenate
create operator pg_catalog.+ (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_add
);

-- add (translate path)
create operator pg_catalog.+ (
  leftarg = path,
  rightarg = point,
  function = pg_catalog.path_add_pt
);

-- add
create operator pg_catalog.+ (
  leftarg = pg_lsn,
  rightarg = numeric,
  function = pg_catalog.pg_lsn_pli
);

-- add points (translate)
create operator pg_catalog.+ (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_add
);

-- add
create operator pg_catalog.+ (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48pl
);

-- add
create operator pg_catalog.+ (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4pl
);

-- add
create operator pg_catalog.+ (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28pl
);

-- add
create operator pg_catalog.+ (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24pl
);

-- add
create operator pg_catalog.+ (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2pl
);

-- convert time with time zone and date to timestamp with time zone
create operator pg_catalog.+ (
  leftarg = time with time zone,
  rightarg = date,
  function = pg_catalog.timetzdate_pl
);

-- add
create operator pg_catalog.+ (
  leftarg = time with time zone,
  rightarg = interval,
  function = pg_catalog.timetz_pl_interval
);

-- convert time and date to timestamp
create operator pg_catalog.+ (
  leftarg = time without time zone,
  rightarg = date,
  function = pg_catalog.timedate_pl
);

-- add
create operator pg_catalog.+ (
  leftarg = time without time zone,
  rightarg = interval,
  function = pg_catalog.time_pl_interval
);

-- add
create operator pg_catalog.+ (
  leftarg = timestamp with time zone,
  rightarg = interval,
  function = pg_catalog.timestamptz_pl_interval
);

-- add
create operator pg_catalog.+ (
  leftarg = timestamp without time zone,
  rightarg = interval,
  function = pg_catalog.timestamp_pl_interval
);

-- negate
create operator pg_catalog.- (
  rightarg = bigint,
  function = pg_catalog.int8um
);

-- negate
create operator pg_catalog.- (
  rightarg = double precision,
  function = pg_catalog.float8um
);

-- negate
create operator pg_catalog.- (
  rightarg = integer,
  function = pg_catalog.int4um
);

-- negate
create operator pg_catalog.- (
  rightarg = interval,
  function = pg_catalog.interval_um
);

-- negate
create operator pg_catalog.- (
  rightarg = numeric,
  function = pg_catalog.numeric_uminus
);

-- negate
create operator pg_catalog.- (
  rightarg = real,
  function = pg_catalog.float4um
);

-- negate
create operator pg_catalog.- (
  rightarg = smallint,
  function = pg_catalog.int2um
);

-- remove ACL item
create operator pg_catalog.- (
  leftarg = aclitem[],
  rightarg = aclitem,
  function = pg_catalog.aclremove
);

-- multirange minus
create operator pg_catalog.- (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_minus
);

-- range difference
create operator pg_catalog.- (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_minus
);

-- subtract
create operator pg_catalog.- (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82mi
);

-- subtract point from box (translate)
create operator pg_catalog.- (
  leftarg = box,
  rightarg = point,
  function = pg_catalog.box_sub
);

-- subtract
create operator pg_catalog.- (
  leftarg = circle,
  rightarg = point,
  function = pg_catalog.circle_sub_pt
);

-- subtract
create operator pg_catalog.- (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = date,
  rightarg = integer,
  function = pg_catalog.date_mii
);

-- subtract
create operator pg_catalog.- (
  leftarg = date,
  rightarg = interval,
  function = pg_catalog.date_mi_interval
);

-- subtract
create operator pg_catalog.- (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = inet,
  rightarg = bigint,
  function = pg_catalog.inetmi_int8
);

-- subtract
create operator pg_catalog.- (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.inetmi
);

-- subtract
create operator pg_catalog.- (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_mi
);

-- delete array element
create operator pg_catalog.- (
  leftarg = jsonb,
  rightarg = integer,
  function = pg_catalog.jsonb_delete
);

-- delete object field
create operator pg_catalog.- (
  leftarg = jsonb,
  rightarg = text,
  function = pg_catalog.jsonb_delete
);

-- delete object fields
create operator pg_catalog.- (
  leftarg = jsonb,
  rightarg = text[],
  function = pg_catalog.jsonb_delete
);

-- subtract
create operator pg_catalog.- (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_sub
);

-- subtract (translate path)
create operator pg_catalog.- (
  leftarg = path,
  rightarg = point,
  function = pg_catalog.path_sub_pt
);

-- subtract
create operator pg_catalog.- (
  leftarg = pg_lsn,
  rightarg = numeric,
  function = pg_catalog.pg_lsn_mii
);

-- minus
create operator pg_catalog.- (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_mi
);

-- subtract points (translate)
create operator pg_catalog.- (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_sub
);

-- subtract
create operator pg_catalog.- (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = time with time zone,
  rightarg = interval,
  function = pg_catalog.timetz_mi_interval
);

-- subtract
create operator pg_catalog.- (
  leftarg = time without time zone,
  rightarg = interval,
  function = pg_catalog.time_mi_interval
);

-- subtract
create operator pg_catalog.- (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_mi_time
);

-- subtract
create operator pg_catalog.- (
  leftarg = timestamp with time zone,
  rightarg = interval,
  function = pg_catalog.timestamptz_mi_interval
);

-- subtract
create operator pg_catalog.- (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_mi
);

-- subtract
create operator pg_catalog.- (
  leftarg = timestamp without time zone,
  rightarg = interval,
  function = pg_catalog.timestamp_mi_interval
);

-- subtract
create operator pg_catalog.- (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_mi
);

-- get json array element
create operator pg_catalog.-> (
  leftarg = json,
  rightarg = integer,
  function = pg_catalog.json_array_element
);

-- get json object field
create operator pg_catalog.-> (
  leftarg = json,
  rightarg = text,
  function = pg_catalog.json_object_field
);

-- get jsonb array element
create operator pg_catalog.-> (
  leftarg = jsonb,
  rightarg = integer,
  function = pg_catalog.jsonb_array_element
);

-- get jsonb object field
create operator pg_catalog.-> (
  leftarg = jsonb,
  rightarg = text,
  function = pg_catalog.jsonb_object_field
);

-- get json array element as text
create operator pg_catalog.->> (
  leftarg = json,
  rightarg = integer,
  function = pg_catalog.json_array_element_text
);

-- get json object field as text
create operator pg_catalog.->> (
  leftarg = json,
  rightarg = text,
  function = pg_catalog.json_object_field_text
);

-- get jsonb array element as text
create operator pg_catalog.->> (
  leftarg = jsonb,
  rightarg = integer,
  function = pg_catalog.jsonb_array_element_text
);

-- get jsonb object field as text
create operator pg_catalog.->> (
  leftarg = jsonb,
  rightarg = text,
  function = pg_catalog.jsonb_object_field_text
);

-- is adjacent to
create operator pg_catalog.-|- (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_adjacent_multirange
);

-- is adjacent to
create operator pg_catalog.-|- (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_adjacent_range
);

-- is adjacent to
create operator pg_catalog.-|- (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_adjacent_multirange
);

-- is adjacent to
create operator pg_catalog.-|- (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_adjacent
);

-- divide
create operator pg_catalog./ (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8div
);

-- divide
create operator pg_catalog./ (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84div
);

-- divide
create operator pg_catalog./ (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82div
);

-- divide box by point (scale)
create operator pg_catalog./ (
  leftarg = box,
  rightarg = point,
  function = pg_catalog.box_div
);

-- divide
create operator pg_catalog./ (
  leftarg = circle,
  rightarg = point,
  function = pg_catalog.circle_div_pt
);

-- divide
create operator pg_catalog./ (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8div
);

-- divide
create operator pg_catalog./ (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84div
);

-- divide
create operator pg_catalog./ (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48div
);

-- divide
create operator pg_catalog./ (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4div
);

-- divide
create operator pg_catalog./ (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42div
);

-- divide
create operator pg_catalog./ (
  leftarg = interval,
  rightarg = double precision,
  function = pg_catalog.interval_div
);

-- divide
create operator pg_catalog./ (
  leftarg = money,
  rightarg = bigint,
  function = pg_catalog.cash_div_int8
);

-- divide
create operator pg_catalog./ (
  leftarg = money,
  rightarg = double precision,
  function = pg_catalog.cash_div_flt8
);

-- divide
create operator pg_catalog./ (
  leftarg = money,
  rightarg = integer,
  function = pg_catalog.cash_div_int4
);

-- divide
create operator pg_catalog./ (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_div_cash
);

-- divide
create operator pg_catalog./ (
  leftarg = money,
  rightarg = real,
  function = pg_catalog.cash_div_flt4
);

-- divide
create operator pg_catalog./ (
  leftarg = money,
  rightarg = smallint,
  function = pg_catalog.cash_div_int2
);

-- divide
create operator pg_catalog./ (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_div
);

-- divide (rotate/scale path)
create operator pg_catalog./ (
  leftarg = path,
  rightarg = point,
  function = pg_catalog.path_div_pt
);

-- divide points (scale/rotate)
create operator pg_catalog./ (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_div
);

-- divide
create operator pg_catalog./ (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48div
);

-- divide
create operator pg_catalog./ (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4div
);

-- divide
create operator pg_catalog./ (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28div
);

-- divide
create operator pg_catalog./ (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24div
);

-- divide
create operator pg_catalog./ (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2div
);

-- less than
create operator pg_catalog.< (
  leftarg = "char",
  rightarg = "char",
  function = pg_catalog.charlt
);

-- less than
create operator pg_catalog.< (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.array_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = anyenum,
  rightarg = anyenum,
  function = pg_catalog.enum_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8lt
);

-- less than
create operator pg_catalog.< (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84lt
);

-- less than
create operator pg_catalog.< (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82lt
);

-- less than
create operator pg_catalog.< (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitlt
);

-- less than
create operator pg_catalog.< (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.varbitlt
);

-- less than
create operator pg_catalog.< (
  leftarg = boolean,
  rightarg = boolean,
  function = pg_catalog.boollt
);

-- less than by area
create operator pg_catalog.< (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.bytealt
);

-- less than
create operator pg_catalog.< (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpcharlt
);

-- less than by area
create operator pg_catalog.< (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = date,
  rightarg = timestamp with time zone,
  function = pg_catalog.date_lt_timestamptz
);

-- less than
create operator pg_catalog.< (
  leftarg = date,
  rightarg = timestamp without time zone,
  function = pg_catalog.date_lt_timestamp
);

-- less than
create operator pg_catalog.< (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8lt
);

-- less than
create operator pg_catalog.< (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84lt
);

-- less than
create operator pg_catalog.< (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48lt
);

-- less than
create operator pg_catalog.< (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4lt
);

-- less than
create operator pg_catalog.< (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42lt
);

-- less than
create operator pg_catalog.< (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_lt
);

-- less than by length
create operator pg_catalog.< (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = name,
  rightarg = name,
  function = pg_catalog.namelt
);

-- less than
create operator pg_catalog.< (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.namelttext
);

-- less than
create operator pg_catalog.< (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = oid,
  rightarg = oid,
  function = pg_catalog.oidlt
);

-- less than
create operator pg_catalog.< (
  leftarg = oidvector,
  rightarg = oidvector,
  function = pg_catalog.oidvectorlt
);

-- less than
create operator pg_catalog.< (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_n_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48lt
);

-- less than
create operator pg_catalog.< (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4lt
);

-- less than
create operator pg_catalog.< (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28lt
);

-- less than
create operator pg_catalog.< (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24lt
);

-- less than
create operator pg_catalog.< (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2lt
);

-- less than
create operator pg_catalog.< (
  leftarg = text,
  rightarg = name,
  function = pg_catalog.textltname
);

-- less than
create operator pg_catalog.< (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = tid,
  rightarg = tid,
  function = pg_catalog.tidlt
);

-- less than
create operator pg_catalog.< (
  leftarg = time with time zone,
  rightarg = time with time zone,
  function = pg_catalog.timetz_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = timestamp with time zone,
  rightarg = date,
  function = pg_catalog.timestamptz_lt_date
);

-- less than
create operator pg_catalog.< (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = timestamp with time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamptz_lt_timestamp
);

-- less than
create operator pg_catalog.< (
  leftarg = timestamp without time zone,
  rightarg = date,
  function = pg_catalog.timestamp_lt_date
);

-- less than
create operator pg_catalog.< (
  leftarg = timestamp without time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamp_lt_timestamptz
);

-- less than
create operator pg_catalog.< (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = uuid,
  rightarg = uuid,
  function = pg_catalog.uuid_lt
);

-- less than
create operator pg_catalog.< (
  leftarg = xid8,
  rightarg = xid8,
  function = pg_catalog.xid8lt
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_distance
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = box,
  rightarg = lseg,
  function = pg_catalog.dist_bs
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = box,
  rightarg = point,
  function = pg_catalog.dist_bp
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_distance
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = circle,
  rightarg = point,
  function = pg_catalog.dist_cpoint
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = circle,
  rightarg = polygon,
  function = pg_catalog.dist_cpoly
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = line,
  rightarg = line,
  function = pg_catalog.line_distance
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = line,
  rightarg = lseg,
  function = pg_catalog.dist_ls
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = line,
  rightarg = point,
  function = pg_catalog.dist_lp
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = lseg,
  rightarg = box,
  function = pg_catalog.dist_sb
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = lseg,
  rightarg = line,
  function = pg_catalog.dist_sl
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_distance
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = lseg,
  rightarg = point,
  function = pg_catalog.dist_sp
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_distance
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = path,
  rightarg = point,
  function = pg_catalog.dist_pathp
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = box,
  function = pg_catalog.dist_pb
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = circle,
  function = pg_catalog.dist_pc
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = line,
  function = pg_catalog.dist_pl
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = lseg,
  function = pg_catalog.dist_ps
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = path,
  function = pg_catalog.dist_ppath
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_distance
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = point,
  rightarg = polygon,
  function = pg_catalog.dist_ppoly
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = polygon,
  rightarg = circle,
  function = pg_catalog.dist_polyc
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = polygon,
  rightarg = point,
  function = pg_catalog.dist_polyp
);

-- distance between
create operator pg_catalog.<-> (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_distance
);

-- phrase-concatenate
create operator pg_catalog.<-> (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_phrase
);

-- is left of
create operator pg_catalog.<< (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_before_multirange
);

-- is left of
create operator pg_catalog.<< (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_before_range
);

-- is left of
create operator pg_catalog.<< (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_before_multirange
);

-- is left of
create operator pg_catalog.<< (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_before
);

-- bitwise shift left
create operator pg_catalog.<< (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int8shl
);

-- bitwise shift left
create operator pg_catalog.<< (
  leftarg = bit,
  rightarg = integer,
  function = pg_catalog.bitshiftleft
);

-- is left of
create operator pg_catalog.<< (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_left
);

-- is left of
create operator pg_catalog.<< (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_left
);

-- is subnet
create operator pg_catalog.<< (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_sub
);

-- bitwise shift left
create operator pg_catalog.<< (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4shl
);

-- is left of
create operator pg_catalog.<< (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_left
);

-- is left of
create operator pg_catalog.<< (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_left
);

-- bitwise shift left
create operator pg_catalog.<< (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int2shl
);

-- is subnet or equal
create operator pg_catalog.<<= (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_subeq
);

-- is below
create operator pg_catalog.<<| (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_below
);

-- is below
create operator pg_catalog.<<| (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_below
);

-- is below
create operator pg_catalog.<<| (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_below
);

-- is below
create operator pg_catalog.<<| (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_below
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = "char",
  rightarg = "char",
  function = pg_catalog.charle
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.array_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = anyenum,
  rightarg = anyenum,
  function = pg_catalog.enum_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitle
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.varbitle
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = boolean,
  rightarg = boolean,
  function = pg_catalog.boolle
);

-- less than or equal by area
create operator pg_catalog.<= (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteale
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpcharle
);

-- less than or equal by area
create operator pg_catalog.<= (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = date,
  rightarg = timestamp with time zone,
  function = pg_catalog.date_le_timestamptz
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = date,
  rightarg = timestamp without time zone,
  function = pg_catalog.date_le_timestamp
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_le
);

-- less than or equal by length
create operator pg_catalog.<= (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = name,
  rightarg = name,
  function = pg_catalog.namele
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameletext
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = oid,
  rightarg = oid,
  function = pg_catalog.oidle
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = oidvector,
  rightarg = oidvector,
  function = pg_catalog.oidvectorle
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_n_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = text,
  rightarg = name,
  function = pg_catalog.textlename
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = tid,
  rightarg = tid,
  function = pg_catalog.tidle
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = time with time zone,
  rightarg = time with time zone,
  function = pg_catalog.timetz_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = timestamp with time zone,
  rightarg = date,
  function = pg_catalog.timestamptz_le_date
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = timestamp with time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamptz_le_timestamp
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = timestamp without time zone,
  rightarg = date,
  function = pg_catalog.timestamp_le_date
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = timestamp without time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamp_le_timestamptz
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = uuid,
  rightarg = uuid,
  function = pg_catalog.uuid_le
);

-- less than or equal
create operator pg_catalog.<= (
  leftarg = xid8,
  rightarg = xid8,
  function = pg_catalog.xid8le
);

-- not equal
create operator pg_catalog.<> (
  leftarg = "char",
  rightarg = "char",
  function = pg_catalog.charne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.array_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = anyenum,
  rightarg = anyenum,
  function = pg_catalog.enum_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.varbitne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = boolean,
  rightarg = boolean,
  function = pg_catalog.boolne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteane
);

-- not equal
create operator pg_catalog.<> (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpcharne
);

-- not equal by area
create operator pg_catalog.<> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = date,
  rightarg = timestamp with time zone,
  function = pg_catalog.date_ne_timestamptz
);

-- not equal
create operator pg_catalog.<> (
  leftarg = date,
  rightarg = timestamp without time zone,
  function = pg_catalog.date_ne_timestamp
);

-- not equal
create operator pg_catalog.<> (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = name,
  rightarg = name,
  function = pg_catalog.namene
);

-- not equal
create operator pg_catalog.<> (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.namenetext
);

-- not equal
create operator pg_catalog.<> (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = oid,
  rightarg = oid,
  function = pg_catalog.oidne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = oidvector,
  rightarg = oidvector,
  function = pg_catalog.oidvectorne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = text,
  rightarg = name,
  function = pg_catalog.textnename
);

-- not equal
create operator pg_catalog.<> (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.textne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = tid,
  rightarg = tid,
  function = pg_catalog.tidne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = time with time zone,
  rightarg = time with time zone,
  function = pg_catalog.timetz_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = timestamp with time zone,
  rightarg = date,
  function = pg_catalog.timestamptz_ne_date
);

-- not equal
create operator pg_catalog.<> (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = timestamp with time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamptz_ne_timestamp
);

-- not equal
create operator pg_catalog.<> (
  leftarg = timestamp without time zone,
  rightarg = date,
  function = pg_catalog.timestamp_ne_date
);

-- not equal
create operator pg_catalog.<> (
  leftarg = timestamp without time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamp_ne_timestamptz
);

-- not equal
create operator pg_catalog.<> (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = uuid,
  rightarg = uuid,
  function = pg_catalog.uuid_ne
);

-- not equal
create operator pg_catalog.<> (
  leftarg = xid,
  rightarg = integer,
  function = pg_catalog.xidneqint4
);

-- not equal
create operator pg_catalog.<> (
  leftarg = xid,
  rightarg = xid,
  function = pg_catalog.xidneq
);

-- not equal
create operator pg_catalog.<> (
  leftarg = xid8,
  rightarg = xid8,
  function = pg_catalog.xid8ne
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.arraycontained
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anyelement,
  rightarg = anymultirange,
  function = pg_catalog.elem_contained_by_multirange
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anyelement,
  rightarg = anyrange,
  function = pg_catalog.elem_contained_by_range
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_contained_by_multirange
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_contained_by_range
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_contained_by_multirange
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_contained_by
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_contained
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_contained
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_contained
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = lseg,
  rightarg = box,
  function = pg_catalog.on_sb
);

-- lseg on line
create operator pg_catalog.<@ (
  leftarg = lseg,
  rightarg = line,
  function = pg_catalog.on_sl
);

-- point inside box
create operator pg_catalog.<@ (
  leftarg = point,
  rightarg = box,
  function = pg_catalog.on_pb
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = point,
  rightarg = circle,
  function = pg_catalog.pt_contained_circle
);

-- point on line
create operator pg_catalog.<@ (
  leftarg = point,
  rightarg = line,
  function = pg_catalog.on_pl
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = point,
  rightarg = lseg,
  function = pg_catalog.on_ps
);

-- point within closed path, or point on open path
create operator pg_catalog.<@ (
  leftarg = point,
  rightarg = path,
  function = pg_catalog.on_ppath
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = point,
  rightarg = polygon,
  function = pg_catalog.pt_contained_poly
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_contained
);

-- is contained by
create operator pg_catalog.<@ (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsq_mcontained
);

-- is below (allows touching)
create operator pg_catalog.<^ (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_below_eq
);

-- deprecated, use <<| instead
create operator pg_catalog.<^ (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_below
);

-- equal
create operator pg_catalog.= (
  leftarg = "char",
  rightarg = "char",
  function = pg_catalog.chareq
);

-- equal
create operator pg_catalog.= (
  leftarg = aclitem,
  rightarg = aclitem,
  function = pg_catalog.aclitemeq
);

-- equal
create operator pg_catalog.= (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.array_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = anyenum,
  rightarg = anyenum,
  function = pg_catalog.enum_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8eq
);

-- equal
create operator pg_catalog.= (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84eq
);

-- equal
create operator pg_catalog.= (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82eq
);

-- equal
create operator pg_catalog.= (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.biteq
);

-- equal
create operator pg_catalog.= (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.varbiteq
);

-- equal
create operator pg_catalog.= (
  leftarg = boolean,
  rightarg = boolean,
  function = pg_catalog.booleq
);

-- equal by area
create operator pg_catalog.= (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteaeq
);

-- equal
create operator pg_catalog.= (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpchareq
);

-- equal
create operator pg_catalog.= (
  leftarg = cid,
  rightarg = cid,
  function = pg_catalog.cideq
);

-- equal by area
create operator pg_catalog.= (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = date,
  rightarg = timestamp with time zone,
  function = pg_catalog.date_eq_timestamptz
);

-- equal
create operator pg_catalog.= (
  leftarg = date,
  rightarg = timestamp without time zone,
  function = pg_catalog.date_eq_timestamp
);

-- equal
create operator pg_catalog.= (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8eq
);

-- equal
create operator pg_catalog.= (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84eq
);

-- equal
create operator pg_catalog.= (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48eq
);

-- equal
create operator pg_catalog.= (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4eq
);

-- equal
create operator pg_catalog.= (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42eq
);

-- equal
create operator pg_catalog.= (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = line,
  rightarg = line,
  function = pg_catalog.line_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = name,
  rightarg = name,
  function = pg_catalog.nameeq
);

-- equal
create operator pg_catalog.= (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameeqtext
);

-- equal
create operator pg_catalog.= (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = oid,
  rightarg = oid,
  function = pg_catalog.oideq
);

-- equal
create operator pg_catalog.= (
  leftarg = oidvector,
  rightarg = oidvector,
  function = pg_catalog.oidvectoreq
);

-- equal
create operator pg_catalog.= (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_n_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48eq
);

-- equal
create operator pg_catalog.= (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4eq
);

-- equal
create operator pg_catalog.= (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28eq
);

-- equal
create operator pg_catalog.= (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24eq
);

-- equal
create operator pg_catalog.= (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2eq
);

-- equal
create operator pg_catalog.= (
  leftarg = text,
  rightarg = name,
  function = pg_catalog.texteqname
);

-- equal
create operator pg_catalog.= (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.texteq
);

-- equal
create operator pg_catalog.= (
  leftarg = tid,
  rightarg = tid,
  function = pg_catalog.tideq
);

-- equal
create operator pg_catalog.= (
  leftarg = time with time zone,
  rightarg = time with time zone,
  function = pg_catalog.timetz_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = timestamp with time zone,
  rightarg = date,
  function = pg_catalog.timestamptz_eq_date
);

-- equal
create operator pg_catalog.= (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = timestamp with time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamptz_eq_timestamp
);

-- equal
create operator pg_catalog.= (
  leftarg = timestamp without time zone,
  rightarg = date,
  function = pg_catalog.timestamp_eq_date
);

-- equal
create operator pg_catalog.= (
  leftarg = timestamp without time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamp_eq_timestamptz
);

-- equal
create operator pg_catalog.= (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = uuid,
  rightarg = uuid,
  function = pg_catalog.uuid_eq
);

-- equal
create operator pg_catalog.= (
  leftarg = xid,
  rightarg = integer,
  function = pg_catalog.xideqint4
);

-- equal
create operator pg_catalog.= (
  leftarg = xid,
  rightarg = xid,
  function = pg_catalog.xideq
);

-- equal
create operator pg_catalog.= (
  leftarg = xid8,
  rightarg = xid8,
  function = pg_catalog.xid8eq
);

-- greater than
create operator pg_catalog.> (
  leftarg = "char",
  rightarg = "char",
  function = pg_catalog.chargt
);

-- greater than
create operator pg_catalog.> (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.array_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = anyenum,
  rightarg = anyenum,
  function = pg_catalog.enum_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitgt
);

-- greater than
create operator pg_catalog.> (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.varbitgt
);

-- greater than
create operator pg_catalog.> (
  leftarg = boolean,
  rightarg = boolean,
  function = pg_catalog.boolgt
);

-- greater than by area
create operator pg_catalog.> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteagt
);

-- greater than
create operator pg_catalog.> (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpchargt
);

-- greater than by area
create operator pg_catalog.> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = date,
  rightarg = timestamp with time zone,
  function = pg_catalog.date_gt_timestamptz
);

-- greater than
create operator pg_catalog.> (
  leftarg = date,
  rightarg = timestamp without time zone,
  function = pg_catalog.date_gt_timestamp
);

-- greater than
create operator pg_catalog.> (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_gt
);

-- greater than by length
create operator pg_catalog.> (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = name,
  rightarg = name,
  function = pg_catalog.namegt
);

-- greater than
create operator pg_catalog.> (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.namegttext
);

-- greater than
create operator pg_catalog.> (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = oid,
  rightarg = oid,
  function = pg_catalog.oidgt
);

-- greater than
create operator pg_catalog.> (
  leftarg = oidvector,
  rightarg = oidvector,
  function = pg_catalog.oidvectorgt
);

-- greater than
create operator pg_catalog.> (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_n_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = text,
  rightarg = name,
  function = pg_catalog.textgtname
);

-- greater than
create operator pg_catalog.> (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = tid,
  rightarg = tid,
  function = pg_catalog.tidgt
);

-- greater than
create operator pg_catalog.> (
  leftarg = time with time zone,
  rightarg = time with time zone,
  function = pg_catalog.timetz_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = timestamp with time zone,
  rightarg = date,
  function = pg_catalog.timestamptz_gt_date
);

-- greater than
create operator pg_catalog.> (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = timestamp with time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamptz_gt_timestamp
);

-- greater than
create operator pg_catalog.> (
  leftarg = timestamp without time zone,
  rightarg = date,
  function = pg_catalog.timestamp_gt_date
);

-- greater than
create operator pg_catalog.> (
  leftarg = timestamp without time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamp_gt_timestamptz
);

-- greater than
create operator pg_catalog.> (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = uuid,
  rightarg = uuid,
  function = pg_catalog.uuid_gt
);

-- greater than
create operator pg_catalog.> (
  leftarg = xid8,
  rightarg = xid8,
  function = pg_catalog.xid8gt
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = "char",
  rightarg = "char",
  function = pg_catalog.charge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.array_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = anyenum,
  rightarg = anyenum,
  function = pg_catalog.enum_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int84ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = bigint,
  rightarg = smallint,
  function = pg_catalog.int82ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.varbitge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = boolean,
  rightarg = boolean,
  function = pg_catalog.boolge
);

-- greater than or equal by area
create operator pg_catalog.>= (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteage
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpcharge
);

-- greater than or equal by area
create operator pg_catalog.>= (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = date,
  rightarg = date,
  function = pg_catalog.date_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = date,
  rightarg = timestamp with time zone,
  function = pg_catalog.date_ge_timestamptz
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = date,
  rightarg = timestamp without time zone,
  function = pg_catalog.date_ge_timestamp
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.float8ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = double precision,
  rightarg = real,
  function = pg_catalog.float84ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = integer,
  rightarg = bigint,
  function = pg_catalog.int48ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = integer,
  rightarg = smallint,
  function = pg_catalog.int42ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = interval,
  rightarg = interval,
  function = pg_catalog.interval_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_ge
);

-- greater than or equal by length
create operator pg_catalog.>= (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = money,
  rightarg = money,
  function = pg_catalog.cash_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = name,
  rightarg = name,
  function = pg_catalog.namege
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.namegetext
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = oid,
  rightarg = oid,
  function = pg_catalog.oidge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = oidvector,
  rightarg = oidvector,
  function = pg_catalog.oidvectorge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_n_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = pg_lsn,
  rightarg = pg_lsn,
  function = pg_catalog.pg_lsn_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = real,
  rightarg = double precision,
  function = pg_catalog.float48ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = real,
  rightarg = real,
  function = pg_catalog.float4ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = record,
  rightarg = record,
  function = pg_catalog.record_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = smallint,
  rightarg = bigint,
  function = pg_catalog.int28ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int24ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = text,
  rightarg = name,
  function = pg_catalog.textgename
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = tid,
  rightarg = tid,
  function = pg_catalog.tidge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = time with time zone,
  rightarg = time with time zone,
  function = pg_catalog.timetz_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = time without time zone,
  rightarg = time without time zone,
  function = pg_catalog.time_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = timestamp with time zone,
  rightarg = date,
  function = pg_catalog.timestamptz_ge_date
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = timestamp with time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamptz_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = timestamp with time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamptz_ge_timestamp
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = timestamp without time zone,
  rightarg = date,
  function = pg_catalog.timestamp_ge_date
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = timestamp without time zone,
  rightarg = timestamp with time zone,
  function = pg_catalog.timestamp_ge_timestamptz
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = timestamp without time zone,
  rightarg = timestamp without time zone,
  function = pg_catalog.timestamp_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = uuid,
  rightarg = uuid,
  function = pg_catalog.uuid_ge
);

-- greater than or equal
create operator pg_catalog.>= (
  leftarg = xid8,
  rightarg = xid8,
  function = pg_catalog.xid8ge
);

-- is right of
create operator pg_catalog.>> (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_after_multirange
);

-- is right of
create operator pg_catalog.>> (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_after_range
);

-- is right of
create operator pg_catalog.>> (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_after_multirange
);

-- is right of
create operator pg_catalog.>> (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_after
);

-- bitwise shift right
create operator pg_catalog.>> (
  leftarg = bigint,
  rightarg = integer,
  function = pg_catalog.int8shr
);

-- bitwise shift right
create operator pg_catalog.>> (
  leftarg = bit,
  rightarg = integer,
  function = pg_catalog.bitshiftright
);

-- is right of
create operator pg_catalog.>> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_right
);

-- is right of
create operator pg_catalog.>> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_right
);

-- is supernet
create operator pg_catalog.>> (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_sup
);

-- bitwise shift right
create operator pg_catalog.>> (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4shr
);

-- is right of
create operator pg_catalog.>> (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_right
);

-- is right of
create operator pg_catalog.>> (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_right
);

-- bitwise shift right
create operator pg_catalog.>> (
  leftarg = smallint,
  rightarg = integer,
  function = pg_catalog.int2shr
);

-- is supernet or equal
create operator pg_catalog.>>= (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.network_supeq
);

-- is above (allows touching)
create operator pg_catalog.>^ (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_above_eq
);

-- deprecated, use |>> instead
create operator pg_catalog.>^ (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_above
);

-- key exists
create operator pg_catalog.? (
  leftarg = jsonb,
  rightarg = text,
  function = pg_catalog.jsonb_exists
);

-- deprecated, use && instead
create operator pg_catalog.?# (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_overlap
);

-- intersect
create operator pg_catalog.?# (
  leftarg = line,
  rightarg = box,
  function = pg_catalog.inter_lb
);

-- intersect
create operator pg_catalog.?# (
  leftarg = line,
  rightarg = line,
  function = pg_catalog.line_intersect
);

-- intersect
create operator pg_catalog.?# (
  leftarg = lseg,
  rightarg = box,
  function = pg_catalog.inter_sb
);

-- intersect
create operator pg_catalog.?# (
  leftarg = lseg,
  rightarg = line,
  function = pg_catalog.inter_sl
);

-- intersect
create operator pg_catalog.?# (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_intersect
);

-- intersect
create operator pg_catalog.?# (
  leftarg = path,
  rightarg = path,
  function = pg_catalog.path_inter
);

-- all keys exist
create operator pg_catalog.?& (
  leftarg = jsonb,
  rightarg = text[],
  function = pg_catalog.jsonb_exists_all
);

-- horizontal
create operator pg_catalog.?- (
  rightarg = line,
  function = pg_catalog.line_horizontal
);

-- horizontal
create operator pg_catalog.?- (
  rightarg = lseg,
  function = pg_catalog.lseg_horizontal
);

-- horizontally aligned
create operator pg_catalog.?- (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_horiz
);

-- perpendicular
create operator pg_catalog.?-| (
  leftarg = line,
  rightarg = line,
  function = pg_catalog.line_perp
);

-- perpendicular
create operator pg_catalog.?-| (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_perp
);

-- vertical
create operator pg_catalog.?| (
  rightarg = line,
  function = pg_catalog.line_vertical
);

-- vertical
create operator pg_catalog.?| (
  rightarg = lseg,
  function = pg_catalog.lseg_vertical
);

-- any key exists
create operator pg_catalog.?| (
  leftarg = jsonb,
  rightarg = text[],
  function = pg_catalog.jsonb_exists_any
);

-- vertically aligned
create operator pg_catalog.?| (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_vert
);

-- parallel
create operator pg_catalog.?|| (
  leftarg = line,
  rightarg = line,
  function = pg_catalog.line_parallel
);

-- parallel
create operator pg_catalog.?|| (
  leftarg = lseg,
  rightarg = lseg,
  function = pg_catalog.lseg_parallel
);

-- absolute value
create operator pg_catalog.@ (
  rightarg = bigint,
  function = pg_catalog.int8abs
);

-- absolute value
create operator pg_catalog.@ (
  rightarg = double precision,
  function = pg_catalog.float8abs
);

-- absolute value
create operator pg_catalog.@ (
  rightarg = integer,
  function = pg_catalog.int4abs
);

-- absolute value
create operator pg_catalog.@ (
  rightarg = numeric,
  function = pg_catalog.numeric_abs
);

-- absolute value
create operator pg_catalog.@ (
  rightarg = real,
  function = pg_catalog.float4abs
);

-- absolute value
create operator pg_catalog.@ (
  rightarg = smallint,
  function = pg_catalog.int2abs
);

-- distance between endpoints
create operator pg_catalog.@-@ (
  rightarg = lseg,
  function = pg_catalog.lseg_length
);

-- sum of path segment lengths
create operator pg_catalog.@-@ (
  rightarg = path,
  function = pg_catalog.path_length
);

-- contains
create operator pg_catalog.@> (
  leftarg = aclitem[],
  rightarg = aclitem,
  function = pg_catalog.aclcontains
);

-- contains
create operator pg_catalog.@> (
  leftarg = anyarray,
  rightarg = anyarray,
  function = pg_catalog.arraycontains
);

-- contains
create operator pg_catalog.@> (
  leftarg = anymultirange,
  rightarg = anyelement,
  function = pg_catalog.multirange_contains_elem
);

-- contains
create operator pg_catalog.@> (
  leftarg = anymultirange,
  rightarg = anymultirange,
  function = pg_catalog.multirange_contains_multirange
);

-- contains
create operator pg_catalog.@> (
  leftarg = anymultirange,
  rightarg = anyrange,
  function = pg_catalog.multirange_contains_range
);

-- contains
create operator pg_catalog.@> (
  leftarg = anyrange,
  rightarg = anyelement,
  function = pg_catalog.range_contains_elem
);

-- contains
create operator pg_catalog.@> (
  leftarg = anyrange,
  rightarg = anymultirange,
  function = pg_catalog.range_contains_multirange
);

-- contains
create operator pg_catalog.@> (
  leftarg = anyrange,
  rightarg = anyrange,
  function = pg_catalog.range_contains
);

-- contains
create operator pg_catalog.@> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_contain
);

-- contains
create operator pg_catalog.@> (
  leftarg = box,
  rightarg = point,
  function = pg_catalog.box_contain_pt
);

-- contains
create operator pg_catalog.@> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_contain
);

-- contains
create operator pg_catalog.@> (
  leftarg = circle,
  rightarg = point,
  function = pg_catalog.circle_contain_pt
);

-- contains
create operator pg_catalog.@> (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_contains
);

-- contains
create operator pg_catalog.@> (
  leftarg = path,
  rightarg = point,
  function = pg_catalog.path_contain_pt
);

-- contains
create operator pg_catalog.@> (
  leftarg = polygon,
  rightarg = point,
  function = pg_catalog.poly_contain_pt
);

-- contains
create operator pg_catalog.@> (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_contain
);

-- contains
create operator pg_catalog.@> (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsq_mcontains
);

-- jsonpath exists
create operator pg_catalog.@? (
  leftarg = jsonb,
  rightarg = jsonpath,
  function = pg_catalog.jsonb_path_exists_opr
);

-- center of
create operator pg_catalog.@@ (
  rightarg = box,
  function = pg_catalog.box_center
);

-- center of
create operator pg_catalog.@@ (
  rightarg = circle,
  function = pg_catalog.circle_center
);

-- center of
create operator pg_catalog.@@ (
  rightarg = lseg,
  function = pg_catalog.lseg_center
);

-- center of
create operator pg_catalog.@@ (
  rightarg = polygon,
  function = pg_catalog.poly_center
);

-- jsonpath match
create operator pg_catalog.@@ (
  leftarg = jsonb,
  rightarg = jsonpath,
  function = pg_catalog.jsonb_path_match_opr
);

-- text search match
create operator pg_catalog.@@ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.ts_match_tt
);

-- text search match
create operator pg_catalog.@@ (
  leftarg = text,
  rightarg = tsquery,
  function = pg_catalog.ts_match_tq
);

-- text search match
create operator pg_catalog.@@ (
  leftarg = tsquery,
  rightarg = tsvector,
  function = pg_catalog.ts_match_qv
);

-- text search match
create operator pg_catalog.@@ (
  leftarg = tsvector,
  rightarg = tsquery,
  function = pg_catalog.ts_match_vq
);

-- deprecated, use @@ instead
create operator pg_catalog.@@@ (
  leftarg = tsquery,
  rightarg = tsvector,
  function = pg_catalog.ts_match_qv
);

-- deprecated, use @@ instead
create operator pg_catalog.@@@ (
  leftarg = tsvector,
  rightarg = tsquery,
  function = pg_catalog.ts_match_vq
);

-- exponentiation
create operator pg_catalog.^ (
  leftarg = double precision,
  rightarg = double precision,
  function = pg_catalog.dpow
);

-- exponentiation
create operator pg_catalog.^ (
  leftarg = numeric,
  rightarg = numeric,
  function = pg_catalog.numeric_power
);

-- starts with
create operator pg_catalog.^@ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.starts_with
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = bigint,
  rightarg = bigint,
  function = pg_catalog.int8or
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = bit,
  rightarg = bit,
  function = pg_catalog.bitor
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = inet,
  rightarg = inet,
  function = pg_catalog.inetor
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = integer,
  rightarg = integer,
  function = pg_catalog.int4or
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = macaddr,
  rightarg = macaddr,
  function = pg_catalog.macaddr_or
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = macaddr8,
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_or
);

-- bitwise or
create operator pg_catalog.| (
  leftarg = smallint,
  rightarg = smallint,
  function = pg_catalog.int2or
);

-- overlaps or is above
create operator pg_catalog.|&> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_overabove
);

-- overlaps or is above
create operator pg_catalog.|&> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_overabove
);

-- overlaps or is above
create operator pg_catalog.|&> (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_overabove
);

-- square root
create operator pg_catalog.|/ (
  rightarg = double precision,
  function = pg_catalog.dsqrt
);

-- is above
create operator pg_catalog.|>> (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_above
);

-- is above
create operator pg_catalog.|>> (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_above
);

-- is above
create operator pg_catalog.|>> (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_above
);

-- is above
create operator pg_catalog.|>> (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_above
);

-- prepend element onto front of array
create operator pg_catalog.|| (
  leftarg = anycompatible,
  rightarg = anycompatiblearray,
  function = pg_catalog.array_prepend
);

-- append element onto end of array
create operator pg_catalog.|| (
  leftarg = anycompatiblearray,
  rightarg = anycompatible,
  function = pg_catalog.array_append
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = anycompatiblearray,
  rightarg = anycompatiblearray,
  function = pg_catalog.array_cat
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = anynonarray,
  rightarg = text,
  function = pg_catalog.anytextcat
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = bit varying,
  rightarg = bit varying,
  function = pg_catalog.bitcat
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.byteacat
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = jsonb,
  rightarg = jsonb,
  function = pg_catalog.jsonb_concat
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = text,
  rightarg = anynonarray,
  function = pg_catalog.textanycat
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.textcat
);

-- OR-concatenate
create operator pg_catalog.|| (
  leftarg = tsquery,
  rightarg = tsquery,
  function = pg_catalog.tsquery_or
);

-- concatenate
create operator pg_catalog.|| (
  leftarg = tsvector,
  rightarg = tsvector,
  function = pg_catalog.tsvector_concat
);

-- cube root
create operator pg_catalog.||/ (
  rightarg = double precision,
  function = pg_catalog.dcbrt
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = bigint,
  function = pg_catalog.int8not
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = bit,
  function = pg_catalog.bitnot
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = inet,
  function = pg_catalog.inetnot
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = integer,
  function = pg_catalog.int4not
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = macaddr,
  function = pg_catalog.macaddr_not
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = macaddr8,
  function = pg_catalog.macaddr8_not
);

-- bitwise not
create operator pg_catalog.~ (
  rightarg = smallint,
  function = pg_catalog.int2not
);

-- matches regular expression, case-sensitive
create operator pg_catalog.~ (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharregexeq
);

-- matches regular expression, case-sensitive
create operator pg_catalog.~ (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameregexeq
);

-- matches regular expression, case-sensitive
create operator pg_catalog.~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.textregexeq
);

-- matches regular expression, case-insensitive
create operator pg_catalog.~* (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharicregexeq
);

-- matches regular expression, case-insensitive
create operator pg_catalog.~* (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameicregexeq
);

-- matches regular expression, case-insensitive
create operator pg_catalog.~* (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.texticregexeq
);

-- less than or equal
create operator pg_catalog.~<=~ (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpchar_pattern_le
);

-- less than or equal
create operator pg_catalog.~<=~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_pattern_le
);

-- less than
create operator pg_catalog.~<~ (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpchar_pattern_lt
);

-- less than
create operator pg_catalog.~<~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_pattern_lt
);

-- same as
create operator pg_catalog.~= (
  leftarg = box,
  rightarg = box,
  function = pg_catalog.box_same
);

-- same as
create operator pg_catalog.~= (
  leftarg = circle,
  rightarg = circle,
  function = pg_catalog.circle_same
);

-- same as
create operator pg_catalog.~= (
  leftarg = point,
  rightarg = point,
  function = pg_catalog.point_eq
);

-- same as
create operator pg_catalog.~= (
  leftarg = polygon,
  rightarg = polygon,
  function = pg_catalog.poly_same
);

-- greater than or equal
create operator pg_catalog.~>=~ (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpchar_pattern_ge
);

-- greater than or equal
create operator pg_catalog.~>=~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_pattern_ge
);

-- greater than
create operator pg_catalog.~>~ (
  leftarg = character,
  rightarg = character,
  function = pg_catalog.bpchar_pattern_gt
);

-- greater than
create operator pg_catalog.~>~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.text_pattern_gt
);

-- matches LIKE expression
create operator pg_catalog.~~ (
  leftarg = bytea,
  rightarg = bytea,
  function = pg_catalog.bytealike
);

-- matches LIKE expression
create operator pg_catalog.~~ (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpcharlike
);

-- matches LIKE expression
create operator pg_catalog.~~ (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.namelike
);

-- matches LIKE expression
create operator pg_catalog.~~ (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.textlike
);

-- matches LIKE expression, case-insensitive
create operator pg_catalog.~~* (
  leftarg = character,
  rightarg = text,
  function = pg_catalog.bpchariclike
);

-- matches LIKE expression, case-insensitive
create operator pg_catalog.~~* (
  leftarg = name,
  rightarg = text,
  function = pg_catalog.nameiclike
);

-- matches LIKE expression, case-insensitive
create operator pg_catalog.~~* (
  leftarg = text,
  rightarg = text,
  function = pg_catalog.texticlike
);

