Add files using upload-large-folder tool

llava_next/include/fakemysql.h

@@ -0,0 +1,335 @@
+/*
+ * fakemysql.h --
+ *
+ *	Fake definitions of the MySQL API sufficient to build tdbc::mysql
+ *	without having an MySQL installation on the build system. This file
+ *	comprises only data type, constant and function definitions.
+ *
+ * The programmers of this file believe that it contains material not
+ * subject to copyright under the doctrines of scenes a faire and
+ * of merger of idea and expression. Accordingly, this file is in the
+ * public domain.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+#ifndef FAKEMYSQL_H_INCLUDED
+#define FAKEMYSQL_H_INCLUDED
+
+#include <stddef.h>
+
+#ifndef MODULE_SCOPE
+#define MODULE_SCOPE extern
+#endif
+
+MODULE_SCOPE Tcl_LoadHandle MysqlInitStubs(Tcl_Interp*);
+
+#ifdef _WIN32
+#define STDCALL __stdcall
+#else
+#define STDCALL /* nothing */
+#endif
+
+enum enum_field_types {
+    MYSQL_TYPE_DECIMAL=0,
+    MYSQL_TYPE_TINY=1,
+    MYSQL_TYPE_SHORT=2,
+    MYSQL_TYPE_LONG=3,
+    MYSQL_TYPE_FLOAT=4,
+    MYSQL_TYPE_DOUBLE=5,
+    MYSQL_TYPE_NULL=6,
+    MYSQL_TYPE_TIMESTAMP=7,
+    MYSQL_TYPE_LONGLONG=8,
+    MYSQL_TYPE_INT24=9,
+    MYSQL_TYPE_DATE=10,
+    MYSQL_TYPE_TIME=11,
+    MYSQL_TYPE_DATETIME=12,
+    MYSQL_TYPE_YEAR=13,
+    MYSQL_TYPE_NEWDATE=14,
+    MYSQL_TYPE_VARCHAR=15,
+    MYSQL_TYPE_BIT=16,
+    MYSQL_TYPE_NEWDECIMAL=246,
+    MYSQL_TYPE_ENUM=247,
+    MYSQL_TYPE_SET=248,
+    MYSQL_TYPE_TINY_BLOB=249,
+    MYSQL_TYPE_MEDIUM_BLOB=250,
+    MYSQL_TYPE_LONG_BLOB=251,
+    MYSQL_TYPE_BLOB=252,
+    MYSQL_TYPE_VAR_STRING=253,
+    MYSQL_TYPE_STRING=254,
+    MYSQL_TYPE_GEOMETRY=255
+};
+
+enum mysql_option {
+    MYSQL_SET_CHARSET_NAME=7,
+};
+
+enum mysql_status {
+    MYSQL_STATUS_READY=0,
+};
+
+#define CLIENT_COMPRESS 	32
+#define CLIENT_INTERACTIVE 1024
+#define MYSQL_DATA_TRUNCATED 101
+#define MYSQL_ERRMSG_SIZE 512
+#define MYSQL_NO_DATA 100
+#define SCRAMBLE_LENGTH 20
+#define SQLSTATE_LENGTH 5
+
+typedef struct st_list LIST;
+typedef struct st_mem_root MEM_ROOT;
+typedef struct st_mysql MYSQL;
+typedef struct st_mysql_bind MYSQL_BIND;
+typedef struct st_mysql_field MYSQL_FIELD;
+typedef struct st_mysql_res MYSQL_RES;
+typedef char** MYSQL_ROW;
+typedef struct st_mysql_stmt MYSQL_STMT;
+typedef char my_bool;
+#ifndef Socket_defined
+typedef int	my_socket;
+#define INVALID_SOCKET -1
+#endif
+typedef Tcl_WideUInt my_ulonglong;
+typedef struct st_net NET;
+typedef struct st_used_mem USED_MEM;
+typedef struct st_vio Vio;
+
+struct st_mem_root {
+  USED_MEM *free;
+  USED_MEM *used;
+  USED_MEM *pre_alloc;
+  size_t min_malloc;
+  size_t block_size;
+  unsigned int block_num;
+  unsigned int first_block_usage;
+  void (*error_handler)(void);
+};
+
+struct st_mysql_options {
+    unsigned int connect_timeout;
+    unsigned int read_timeout;
+    unsigned int write_timeout;
+    unsigned int port;
+    unsigned int protocol;
+    unsigned long client_flag;
+    char *host;
+    char *user;
+    char *password;
+    char *unix_socket;
+    char *db;
+    struct st_dynamic_array *init_commands;
+    char *my_cnf_file;
+    char *my_cnf_group;
+    char *charset_dir;
+    char *charset_name;
+    char *ssl_key;
+    char *ssl_cert;
+    char *ssl_ca;
+    char *ssl_capath;
+    char *ssl_cipher;
+    char *shared_memory_base_name;
+    unsigned long max_allowed_packet;
+    my_bool use_ssl;
+    my_bool compress,named_pipe;
+    my_bool rpl_probe;
+    my_bool rpl_parse;
+    my_bool no_master_reads;
+#if !defined(CHECK_EMBEDDED_DIFFERENCES) || defined(EMBEDDED_LIBRARY)
+    my_bool separate_thread;
+#endif
+    enum mysql_option methods_to_use;
+    char *client_ip;
+    my_bool secure_auth;
+    my_bool report_data_truncation;
+    int (*local_infile_init)(void **, const char *, void *);
+    int (*local_infile_read)(void *, char *, unsigned int);
+    void (*local_infile_end)(void *);
+    int (*local_infile_error)(void *, char *, unsigned int);
+    void *local_infile_userdata;
+    void *extension;
+};
+
+struct st_net {
+#if !defined(CHECK_EMBEDDED_DIFFERENCES) || !defined(EMBEDDED_LIBRARY)
+    Vio *vio;
+    unsigned char *buff;
+    unsigned char *buff_end;
+    unsigned char *write_pos;
+    unsigned char *read_pos;
+    my_socket fd;
+    unsigned long remain_in_buf;
+    unsigned long length;
+    unsigned long buf_length;
+    unsigned long where_b;
+    unsigned long max_packet;
+    unsigned long max_packet_size;
+    unsigned int pkt_nr;
+    unsigned int compress_pkt_nr;
+    unsigned int write_timeout;
+    unsigned int read_timeout;
+    unsigned int retry_count;
+    int fcntl;
+    unsigned int *return_status;
+    unsigned char reading_or_writing;
+    char save_char;
+    my_bool unused0;
+    my_bool unused;
+    my_bool compress;
+    my_bool unused1;
+#endif
+    unsigned char *query_cache_query;
+    unsigned int last_errno;
+    unsigned char error;
+    my_bool unused2;
+    my_bool return_errno;
+    char last_error[MYSQL_ERRMSG_SIZE];
+    char sqlstate[SQLSTATE_LENGTH+1];
+    void *extension;
+#if defined(MYSQL_SERVER) && !defined(EMBEDDED_LIBRARY)
+    my_bool skip_big_packet;
+#endif
+};
+
+/*
+ * st_mysql differs between 5.0 and 5.1, but the 5.0 version is a
+ * strict subset, we don't use any of the 5.1 fields, and we don't
+ * ever allocate the structure ourselves.
+ */
+
+struct st_mysql {
+    NET net;
+    unsigned char *connector_fd;
+    char *host;
+    char *user;
+    char *passwd;
+    char *unix_socket;
+    char *server_version;
+    char *host_info;
+    char *info;
+    char *db;
+    struct charset_info_st *charset;
+    MYSQL_FIELD *fields;
+    MEM_ROOT field_alloc;
+    my_ulonglong affected_rows;
+    my_ulonglong insert_id;
+    my_ulonglong extra_info;
+    unsigned long thread_id;
+    unsigned long packet_length;
+    unsigned int port;
+    unsigned long client_flag;
+    unsigned long server_capabilities;
+    unsigned int protocol_version;
+    unsigned int field_count;
+    unsigned int server_status;
+    unsigned int server_language;
+    unsigned int warning_count;
+    struct st_mysql_options options;
+    enum mysql_status status;
+    my_bool free_me;
+    my_bool reconnect;
+    char scramble[SCRAMBLE_LENGTH+1];
+    my_bool rpl_pivot;
+    struct st_mysql *master;
+    struct st_mysql *next_slave;
+    struct st_mysql* last_used_slave;
+    struct st_mysql* last_used_con;
+    LIST  *stmts;
+    const struct st_mysql_methods *methods;
+    void *thd;
+    my_bool *unbuffered_fetch_owner;
+    char *info_buffer;
+};
+
+/*
+ * There are different version of the MYSQL_BIND structure before and after
+ * MySQL 5.1. We go after the fields of the structure using accessor functions
+ * so that the code in this file is compatible with both versions.
+ */
+
+struct st_mysql_bind_51 {	/* Post-5.1 */
+    unsigned long* length;
+    my_bool* is_null;
+    void* buffer;
+    my_bool* error;
+    unsigned char* row_ptr;
+    void (*store_param_func)(NET* net, MYSQL_BIND* param);
+    void (*fetch_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+    void (*skip_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+    unsigned long buffer_length;
+    unsigned long offset;
+    unsigned long length_value;
+    unsigned int param_number;
+    unsigned int pack_length;
+    enum enum_field_types buffer_type;
+    my_bool error_value;
+    my_bool is_unsigned;
+    my_bool long_data_used;
+    my_bool is_null_value;
+    void* extension;
+};
+
+struct st_mysql_bind_50 {	/* Pre-5.1 */
+    unsigned long* length;
+    my_bool* is_null;
+    void* buffer;
+    my_bool* error;
+    enum enum_field_types buffer_type;
+    unsigned long buffer_length;
+    unsigned char* row_ptr;
+    unsigned long offset;
+    unsigned long length_value;
+    unsigned int param_number;
+    unsigned int pack_length;
+    my_bool error_value;
+    my_bool is_unsigned;
+    my_bool long_data_used;
+    my_bool is_null_value;
+    void (*store_param_func)(NET* net, MYSQL_BIND* param);
+    void (*fetch_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+    void (*skip_result)(MYSQL_BIND*, MYSQL_FIELD*, unsigned char**);
+};
+
+/*
+ * There are also different versions of the MYSQL_FIELD structure; fortunately,
+ * the 5.1 version is a strict extension of the 5.0 version.
+ */
+
+struct st_mysql_field {
+    char* name;
+    char *org_name;
+    char* table;
+    char* org_table;
+    char* db;
+    char* catalog;
+    char* def;
+    unsigned long length;
+    unsigned long max_length;
+    unsigned int name_length;
+    unsigned int org_name_length;
+    unsigned int table_length;
+    unsigned int org_table_length;
+    unsigned int db_length;
+    unsigned int catalog_length;
+    unsigned int def_length;
+    unsigned int flags;
+    unsigned int decimals;
+    unsigned int charsetnr;
+    enum enum_field_types type;
+};
+struct st_mysql_field_50 {
+    struct st_mysql_field field;
+};
+struct st_mysql_field_51 {
+    struct st_mysql_field field;
+    void* extension;
+};
+#define NOT_NULL_FLAG 1
+
+#define IS_NUM(t)	((t) <= MYSQL_TYPE_INT24 || (t) == MYSQL_TYPE_YEAR || (t) == MYSQL_TYPE_NEWDECIMAL)
+
+#define mysql_library_init mysql_server_init
+#define mysql_library_end mysql_server_end
+
+#include "mysqlStubs.h"
+
+#endif /* not FAKEMYSQL_H_INCLUDED */

llava_next/include/itclInt.h

@@ -0,0 +1,854 @@
+/*
+ * itclInt.h --
+ *
+ * This file contains internal definitions for the C-implemented part of a
+ * Itcl
+ *
+ * Copyright (c) 2007 by Arnulf P. Wiedemann
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+#include <stddef.h>
+
+/*
+ * Used to tag functions that are only to be visible within the module being
+ * built and not outside it (where this is supported by the linker).
+ */
+
+#ifndef MODULE_SCOPE
+#   ifdef __cplusplus
+#       define MODULE_SCOPE extern "C"
+#   else
+#       define MODULE_SCOPE extern
+#   endif
+#endif
+
+#include <string.h>
+#include <ctype.h>
+#include <tclOO.h>
+#include "itcl.h"
+#include "itclMigrate2TclCore.h"
+#include "itclTclIntStubsFcn.h"
+
+/*
+ * Utility macros: STRINGIFY takes an argument and wraps it in "" (double
+ * quotation marks).
+ */
+
+#ifndef STRINGIFY
+#  define STRINGIFY(x) STRINGIFY1(x)
+#  define STRINGIFY1(x) #x
+#endif
+
+/*
+ * MSVC 8.0 started to mark many standard C library functions depreciated
+ * including the *printf family and others. Tell it to shut up.
+ * (_MSC_VER is 1200 for VC6, 1300 or 1310 for vc7.net, 1400 for 8.0)
+ */
+#if defined(_MSC_VER)
+#   pragma warning(disable:4244)
+#   if _MSC_VER >= 1400
+#	pragma warning(disable:4267)
+#	pragma warning(disable:4996)
+#   endif
+#endif
+
+#ifndef TCL_INDEX_NONE
+# define TCL_INDEX_NONE	(-1)
+#endif
+
+#ifndef JOIN
+#  define JOIN(a,b) JOIN1(a,b)
+#  define JOIN1(a,b) a##b
+#endif
+
+#ifndef TCL_UNUSED
+#   if defined(__cplusplus)
+#	define TCL_UNUSED(T) T
+#   elif defined(__GNUC__) && (__GNUC__ > 2)
+#	define TCL_UNUSED(T) T JOIN(dummy, __LINE__) __attribute__((unused))
+#   else
+#	define TCL_UNUSED(T) T JOIN(dummy, __LINE__)
+#   endif
+#endif
+
+#if TCL_MAJOR_VERSION == 8
+#   define ITCL_Z_MODIFIER ""
+#else
+#   define ITCL_Z_MODIFIER TCL_Z_MODIFIER
+#endif
+
+/*
+ * Since the Tcl/Tk distribution doesn't perform any asserts,
+ * dynamic loading can fail to find the __assert function.
+ * As a workaround, we'll include our own.
+ */
+
+#undef  assert
+#if defined(NDEBUG) && !defined(DEBUG)
+#define assert(EX) ((void)0)
+#else /* !NDEBUG || DEBUG */
+#define assert(EX) (void)((EX) || (Itcl_Assert(STRINGIFY(EX), __FILE__, __LINE__), 0))
+#endif
+
+#define ITCL_INTERP_DATA "itcl_data"
+#define ITCL_TK_VERSION "8.6"
+
+/*
+ * Convenience macros for iterating through hash tables. FOREACH_HASH_DECLS
+ * sets up the declarations needed for the main macro, FOREACH_HASH, which
+ * does the actual iteration. FOREACH_HASH_VALUE is a restricted version that
+ * only iterates over values.
+ */
+
+#define FOREACH_HASH_DECLS \
+    Tcl_HashEntry *hPtr;Tcl_HashSearch search
+#define FOREACH_HASH(key,val,tablePtr) \
+    for(hPtr=Tcl_FirstHashEntry((tablePtr),&search); hPtr!=NULL ? \
+	    (*(void **)&(key)=Tcl_GetHashKey((tablePtr),hPtr),\
+	    *(void **)&(val)=Tcl_GetHashValue(hPtr),1):0; hPtr=Tcl_NextHashEntry(&search))
+#define FOREACH_HASH_VALUE(val,tablePtr) \
+    for(hPtr=Tcl_FirstHashEntry((tablePtr),&search); hPtr!=NULL ? \
+	    (*(void **)&(val)=Tcl_GetHashValue(hPtr),1):0;hPtr=Tcl_NextHashEntry(&search))
+
+/*
+ * What sort of size of things we like to allocate.
+ */
+
+#define ALLOC_CHUNK 8
+
+#define ITCL_INT_NAMESPACE	    ITCL_NAMESPACE"::internal"
+#define ITCL_INTDICTS_NAMESPACE	    ITCL_INT_NAMESPACE"::dicts"
+#define ITCL_VARIABLES_NAMESPACE    ITCL_INT_NAMESPACE"::variables"
+#define ITCL_COMMANDS_NAMESPACE	    ITCL_INT_NAMESPACE"::commands"
+
+typedef struct ItclFoundation {
+    Itcl_Stack methodCallStack;
+    Tcl_Command dispatchCommand;
+} ItclFoundation;
+
+typedef struct ItclArgList {
+    struct ItclArgList *nextPtr;        /* pointer to next argument */
+    Tcl_Obj *namePtr;           /* name of the argument */
+    Tcl_Obj *defaultValuePtr;   /* default value or NULL if none */
+} ItclArgList;
+
+/*
+ *  Common info for managing all known objects.
+ *  Each interpreter has one of these data structures stored as
+ *  clientData in the "itcl" namespace.  It is also accessible
+ *  as associated data via the key ITCL_INTERP_DATA.
+ */
+struct ItclClass;
+struct ItclObject;
+struct ItclMemberFunc;
+struct EnsembleInfo;
+struct ItclDelegatedOption;
+struct ItclDelegatedFunction;
+
+typedef struct ItclObjectInfo {
+    Tcl_Interp *interp;             /* interpreter that manages this info */
+    Tcl_HashTable objects;          /* list of all known objects key is
+                                     * ioPtr */
+    Tcl_HashTable objectCmds;       /* list of known objects using accessCmd */
+    Tcl_HashTable unused5;          /* list of known objects using namePtr */
+    Tcl_HashTable classes;          /* list of all known classes,
+                                     * key is iclsPtr */
+    Tcl_HashTable nameClasses;      /* maps from fullNamePtr to iclsPtr */
+    Tcl_HashTable namespaceClasses; /* maps from nsPtr to iclsPtr */
+    Tcl_HashTable procMethods;      /* maps from procPtr to mFunc */
+    Tcl_HashTable instances;        /* maps from instanceNumber to ioPtr */
+    Tcl_HashTable unused8;          /* maps from ioPtr to instanceNumber */
+    Tcl_HashTable frameContext;     /* maps frame to context stack */
+    Tcl_HashTable classTypes;       /* maps from class type i.e. "widget"
+                                     * to define value i.e. ITCL_WIDGET */
+    int protection;                 /* protection level currently in effect */
+    int useOldResolvers;            /* whether to use the "old" style
+                                     * resolvers or the CallFrame resolvers */
+    Itcl_Stack clsStack;            /* stack of class definitions currently
+                                     * being parsed */
+    Itcl_Stack unused;              /* Removed */
+    Itcl_Stack unused6;		    /* obsolete field */
+    struct ItclObject *currIoPtr;   /* object currently being constructed
+                                     * set only during calling of constructors
+				     * otherwise NULL */
+    Tcl_ObjectMetadataType *class_meta_type;
+                                    /* type for getting the Itcl class info
+                                     * from a TclOO Tcl_Object */
+    const Tcl_ObjectMetadataType *object_meta_type;
+                                    /* type for getting the Itcl object info
+                                     * from a TclOO Tcl_Object */
+    Tcl_Object clazzObjectPtr;      /* the root object of Itcl */
+    Tcl_Class clazzClassPtr;        /* the root class of Itcl */
+    struct EnsembleInfo *ensembleInfo;
+    struct ItclClass *currContextIclsPtr;
+                                    /* context class for delegated option
+                                     * handling */
+    int currClassFlags;             /* flags for the class just in creation */
+    int buildingWidget;             /* set if in construction of a widget */
+    Tcl_Size unparsedObjc;         /* number options not parsed by
+                                       ItclExtendedConfigure/-Cget function */
+    Tcl_Obj **unparsedObjv;         /* options not parsed by
+                                       ItclExtendedConfigure/-Cget function */
+    int functionFlags;              /* used for creating of ItclMemberCode */
+    int unused7;
+    struct ItclDelegatedOption *currIdoPtr;
+                                    /* the current delegated option info */
+    int inOptionHandling;           /* used to indicate for type/widget ...
+                                     * that there is an option processing
+				     * and methods are allowed to be called */
+            /* these are the Tcl_Obj Ptrs for the clazz unknown procedure */
+	    /* need to store them to be able to free them at the end */
+    int itclWidgetInitted;          /* set to 1 if itclWidget.tcl has already
+                                     * been called
+				     */
+    int itclHullCmdsInitted;        /* set to 1 if itclHullCmds.tcl has already
+                                     * been called
+				     */
+    Tcl_Obj *unused2;
+    Tcl_Obj *unused3;
+    Tcl_Obj *unused4;
+    Tcl_Obj *infoVarsPtr;
+    Tcl_Obj *unused9;
+    Tcl_Obj *infoVars4Ptr;
+    Tcl_Obj *typeDestructorArgumentPtr;
+    struct ItclObject *lastIoPtr;   /* last object constructed */
+    Tcl_Command infoCmd;
+} ItclObjectInfo;
+
+typedef struct EnsembleInfo {
+    Tcl_HashTable ensembles;        /* list of all known ensembles */
+    Tcl_HashTable subEnsembles;     /* list of all known subensembles */
+    Tcl_Size numEnsembles;
+    Tcl_Namespace *ensembleNsPtr;
+} EnsembleInfo;
+/*
+ *  Representation for each [incr Tcl] class.
+ */
+#define ITCL_CLASS		              0x1
+#define ITCL_TYPE		              0x2
+#define ITCL_WIDGET		              0x4
+#define ITCL_WIDGETADAPTOR	              0x8
+#define ITCL_ECLASS		             0x10
+#define ITCL_NWIDGET		             0x20
+#define ITCL_WIDGET_FRAME	             0x40
+#define ITCL_WIDGET_LABEL_FRAME	             0x80
+#define ITCL_WIDGET_TOPLEVEL	            0x100
+#define ITCL_WIDGET_TTK_FRAME               0x200
+#define ITCL_WIDGET_TTK_LABEL_FRAME	    0x400
+#define ITCL_WIDGET_TTK_TOPLEVEL            0x800
+#define ITCL_CLASS_IS_DELETED              0x1000
+#define ITCL_CLASS_IS_DESTROYED            0x2000
+#define ITCL_CLASS_NS_IS_DESTROYED         0x4000
+#define ITCL_CLASS_IS_RENAMED              0x8000 /* unused */
+#define ITCL_CLASS_IS_FREED               0x10000
+#define ITCL_CLASS_DERIVED_RELEASED       0x20000
+#define ITCL_CLASS_NS_TEARDOWN            0x40000
+#define ITCL_CLASS_NO_VARNS_DELETE        0x80000
+#define ITCL_CLASS_SHOULD_VARNS_DELETE   0x100000
+#define ITCL_CLASS_DESTRUCTOR_CALLED     0x400000
+
+
+typedef struct ItclClass {
+    Tcl_Obj *namePtr;             /* class name */
+    Tcl_Obj *fullNamePtr;         /* fully qualified class name */
+    Tcl_Interp *interp;           /* interpreter that manages this info */
+    Tcl_Namespace *nsPtr;         /* namespace representing class scope */
+    Tcl_Command accessCmd;        /* access command for creating instances */
+    Tcl_Command thisCmd;          /* needed for deletion of class */
+
+    struct ItclObjectInfo *infoPtr;
+                                  /* info about all known objects
+				   * and other stuff like stacks */
+    Itcl_List bases;              /* list of base classes */
+    Itcl_List derived;            /* list of all derived classes */
+    Tcl_HashTable heritage;       /* table of all base classes.  Look up
+                                   * by pointer to class definition.  This
+                                   * provides fast lookup for inheritance
+                                   * tests. */
+    Tcl_Obj *initCode;            /* initialization code for new objs */
+    Tcl_HashTable variables;      /* definitions for all data members
+                                     in this class.  Look up simple string
+                                     names and get back ItclVariable* ptrs */
+    Tcl_HashTable options;        /* definitions for all option members
+                                     in this class.  Look up simple string
+                                     names and get back ItclOption* ptrs */
+    Tcl_HashTable components;     /* definitions for all component members
+                                     in this class.  Look up simple string
+                                     names and get back ItclComponent* ptrs */
+    Tcl_HashTable functions;      /* definitions for all member functions
+                                     in this class.  Look up simple string
+                                     names and get back ItclMemberFunc* ptrs */
+    Tcl_HashTable delegatedOptions; /* definitions for all delegated options
+                                     in this class.  Look up simple string
+                                     names and get back
+				     ItclDelegatedOption * ptrs */
+    Tcl_HashTable delegatedFunctions; /* definitions for all delegated methods
+                                     or procs in this class.  Look up simple
+				     string names and get back
+				     ItclDelegatedFunction * ptrs */
+    Tcl_HashTable methodVariables; /* definitions for all methodvariable members
+                                     in this class.  Look up simple string
+                                     names and get back
+				     ItclMethodVariable* ptrs */
+    Tcl_Size numInstanceVars;    /* number of instance vars in variables
+                                     table */
+    Tcl_HashTable classCommons;   /* used for storing variable namespace
+                                   * string for Tcl_Resolve */
+    Tcl_HashTable resolveVars;    /* all possible names for variables in
+                                   * this class (e.g., x, foo::x, etc.) */
+    Tcl_HashTable resolveCmds;    /* all possible names for functions in
+                                   * this class (e.g., x, foo::x, etc.) */
+    Tcl_HashTable contextCache;   /* cache for function contexts */
+    struct ItclMemberFunc *unused2;
+                                  /* the class constructor or NULL */
+    struct ItclMemberFunc *unused3;
+                                  /* the class destructor or NULL */
+    struct ItclMemberFunc *unused1;
+    Tcl_Resolve *resolvePtr;
+    Tcl_Obj *widgetClassPtr;      /* class name for widget if class is a
+                                   * ::itcl::widget */
+    Tcl_Obj *hullTypePtr;         /* hulltype name for widget if class is a
+                                   * ::itcl::widget */
+    Tcl_Object oPtr;		  /* TclOO class object */
+    Tcl_Class  clsPtr;            /* TclOO class */
+    Tcl_Size numCommons;         /* number of commons in this class */
+    Tcl_Size numVariables;       /* number of variables in this class */
+    Tcl_Size numOptions;         /* number of options in this class */
+    Tcl_Size unique;             /* unique number for #auto generation */
+    int flags;                    /* maintains class status */
+    Tcl_Size callRefCount;       /* prevent deleting of class if refcount>1 */
+    Tcl_Obj *typeConstructorPtr;  /* initialization for types */
+    int destructorHasBeenCalled;  /* prevent multiple invocations of destrcutor */
+    Tcl_Size refCount;
+} ItclClass;
+
+typedef struct ItclHierIter {
+    ItclClass *current;           /* current position in hierarchy */
+    Itcl_Stack stack;             /* stack used for traversal */
+} ItclHierIter;
+
+#define ITCL_OBJECT_IS_DELETED           0x01
+#define ITCL_OBJECT_IS_DESTRUCTED        0x02
+#define ITCL_OBJECT_IS_DESTROYED         0x04
+#define ITCL_OBJECT_IS_RENAMED           0x08
+#define ITCL_OBJECT_CLASS_DESTRUCTED     0x10
+#define ITCL_TCLOO_OBJECT_IS_DELETED     0x20
+#define ITCL_OBJECT_DESTRUCT_ERROR       0x40
+#define ITCL_OBJECT_SHOULD_VARNS_DELETE  0x80
+#define ITCL_OBJECT_ROOT_METHOD          0x8000
+
+/*
+ *  Representation for each [incr Tcl] object.
+ */
+typedef struct ItclObject {
+    ItclClass *iclsPtr;          /* most-specific class */
+    Tcl_Command accessCmd;       /* object access command */
+
+    Tcl_HashTable *constructed;  /* temp storage used during construction */
+    Tcl_HashTable *destructed;   /* temp storage used during destruction */
+    Tcl_HashTable objectVariables;
+                                 /* used for storing Tcl_Var entries for
+				  * variable resolving, key is ivPtr of
+				  * variable, value is varPtr */
+    Tcl_HashTable objectOptions; /* definitions for all option members
+                                     in this object. Look up option namePtr
+                                     names and get back ItclOption* ptrs */
+    Tcl_HashTable objectComponents; /* definitions for all component members
+                                     in this object. Look up component namePtr
+                                     names and get back ItclComponent* ptrs */
+    Tcl_HashTable objectMethodVariables;
+                                 /* definitions for all methodvariable members
+                                     in this object. Look up methodvariable
+				     namePtr names and get back
+				     ItclMethodVariable* ptrs */
+    Tcl_HashTable objectDelegatedOptions;
+                                  /* definitions for all delegated option
+				     members in this object. Look up option
+				     namePtr names and get back
+				     ItclOption* ptrs */
+    Tcl_HashTable objectDelegatedFunctions;
+                                  /* definitions for all delegated function
+				     members in this object. Look up function
+				     namePtr names and get back
+				     ItclMemberFunc * ptrs */
+    Tcl_HashTable contextCache;   /* cache for function contexts */
+    Tcl_Obj *namePtr;
+    Tcl_Obj *origNamePtr;         /* the original name before any rename */
+    Tcl_Obj *createNamePtr;       /* the temp name before any rename
+                                   * mostly used for widgetadaptor
+				   * because that hijackes the name
+				   * often when installing the hull */
+    Tcl_Interp *interp;
+    ItclObjectInfo *infoPtr;
+    Tcl_Obj *varNsNamePtr;
+    Tcl_Object oPtr;             /* the TclOO object */
+    Tcl_Resolve *resolvePtr;
+    int flags;
+    Tcl_Size callRefCount;       /* prevent deleting of object if refcount > 1 */
+    Tcl_Obj *hullWindowNamePtr;   /* the window path name for the hull
+                                   * (before renaming in installhull) */
+    int destructorHasBeenCalled;  /* is set when the destructor is called
+                                   * to avoid callin destructor twice */
+    int noComponentTrace;         /* don't call component traces if
+                                   * setting components in DelegationInstall */
+    int hadConstructorError;      /* needed for multiple calls of CallItclObjectCmd */
+} ItclObject;
+
+#define ITCL_IGNORE_ERRS  0x002  /* useful for construction/destruction */
+
+typedef struct ItclResolveInfo {
+    int flags;
+    ItclClass *iclsPtr;
+    ItclObject *ioPtr;
+} ItclResolveInfo;
+
+#define ITCL_RESOLVE_CLASS		0x01
+#define ITCL_RESOLVE_OBJECT		0x02
+
+/*
+ *  Implementation for any code body in an [incr Tcl] class.
+ */
+typedef struct ItclMemberCode {
+    int flags;                  /* flags describing implementation */
+    Tcl_Size argcount;         /* number of args in arglist */
+    Tcl_Size maxargcount;      /* max number of args in arglist */
+    Tcl_Obj *usagePtr;          /* usage string for error messages */
+    Tcl_Obj *argumentPtr;       /* the function arguments */
+    Tcl_Obj *bodyPtr;           /* the function body */
+    ItclArgList *argListPtr;    /* the parsed arguments */
+    union {
+        Tcl_CmdProc *argCmd;    /* (argc,argv) C implementation */
+        Tcl_ObjCmdProc *objCmd; /* (objc,objv) C implementation */
+    } cfunc;
+    void *clientData;           /* client data for C implementations */
+} ItclMemberCode;
+
+/*
+ *  Flag bits for ItclMemberCode:
+ */
+#define ITCL_IMPLEMENT_NONE    0x001  /* no implementation */
+#define ITCL_IMPLEMENT_TCL     0x002  /* Tcl implementation */
+#define ITCL_IMPLEMENT_ARGCMD  0x004  /* (argc,argv) C implementation */
+#define ITCL_IMPLEMENT_OBJCMD  0x008  /* (objc,objv) C implementation */
+#define ITCL_IMPLEMENT_C       0x00c  /* either kind of C implementation */
+
+#define Itcl_IsMemberCodeImplemented(mcode) \
+    (((mcode)->flags & ITCL_IMPLEMENT_NONE) == 0)
+
+/*
+ *  Flag bits for ItclMember: functions and variables
+ */
+#define ITCL_COMMON            0x010  /* non-zero => is a "proc" or common
+                                       * variable */
+
+/*
+ *  Flag bits for ItclMember: functions
+ */
+#define ITCL_CONSTRUCTOR       0x020  /* non-zero => is a constructor */
+#define ITCL_DESTRUCTOR        0x040  /* non-zero => is a destructor */
+#define ITCL_ARG_SPEC          0x080  /* non-zero => has an argument spec */
+#define ITCL_BODY_SPEC         0x100  /* non-zero => has an body spec */
+#define ITCL_BUILTIN           0x400  /* non-zero => built-in method */
+#define ITCL_COMPONENT         0x800  /* non-zero => component */
+#define ITCL_TYPE_METHOD       0x1000 /* non-zero => typemethod */
+#define ITCL_METHOD            0x2000 /* non-zero => method */
+
+/*
+ *  Flag bits for ItclMember: variables
+ */
+#define ITCL_THIS_VAR          0x20   /* non-zero => built-in "this" variable */
+#define ITCL_OPTIONS_VAR       0x40   /* non-zero => built-in "itcl_options"
+                                       * variable */
+#define ITCL_TYPE_VAR          0x80   /* non-zero => built-in "type" variable */
+                                      /* no longer used ??? */
+#define ITCL_SELF_VAR          0x100  /* non-zero => built-in "self" variable */
+#define ITCL_SELFNS_VAR        0x200  /* non-zero => built-in "selfns"
+                                       * variable */
+#define ITCL_WIN_VAR           0x400  /* non-zero => built-in "win" variable */
+#define ITCL_COMPONENT_VAR     0x800  /* non-zero => component variable */
+#define ITCL_HULL_VAR          0x1000 /* non-zero => built-in "itcl_hull"
+                                       * variable */
+#define ITCL_OPTION_READONLY   0x2000 /* non-zero => readonly */
+#define ITCL_VARIABLE          0x4000 /* non-zero => normal variable */
+#define ITCL_TYPE_VARIABLE     0x8000 /* non-zero => typevariable */
+#define ITCL_OPTION_INITTED    0x10000 /* non-zero => option has been initialized */
+#define ITCL_OPTION_COMP_VAR   0x20000 /* variable to collect option components of extendedclass  */
+
+/*
+ *  Instance components.
+ */
+struct ItclVariable;
+typedef struct ItclComponent {
+    Tcl_Obj *namePtr;           /* member name */
+    struct ItclVariable *ivPtr; /* variable for this component */
+    int flags;
+    int haveKeptOptions;
+    Tcl_HashTable keptOptions;  /* table of options to keep */
+} ItclComponent;
+
+#define ITCL_COMPONENT_INHERIT	0x01
+#define ITCL_COMPONENT_PUBLIC	0x02
+
+typedef struct ItclDelegatedFunction {
+    Tcl_Obj *namePtr;
+    ItclComponent *icPtr;
+    Tcl_Obj *asPtr;
+    Tcl_Obj *usingPtr;
+    Tcl_HashTable exceptions;
+    int flags;
+} ItclDelegatedFunction;
+
+/*
+ *  Representation of member functions in an [incr Tcl] class.
+ */
+typedef struct ItclMemberFunc {
+    Tcl_Obj* namePtr;           /* member name */
+    Tcl_Obj* fullNamePtr;       /* member name with "class::" qualifier */
+    ItclClass* iclsPtr;         /* class containing this member */
+    int protection;             /* protection level */
+    int flags;                  /* flags describing member (see above) */
+    ItclObjectInfo *infoPtr;
+    ItclMemberCode *codePtr;    /* code associated with member */
+    Tcl_Command accessCmd;      /* Tcl command installed for this function */
+    Tcl_Size argcount;         /* number of args in arglist */
+    Tcl_Size maxargcount;      /* max number of args in arglist */
+    Tcl_Obj *usagePtr;          /* usage string for error messages */
+    Tcl_Obj *argumentPtr;       /* the function arguments */
+    Tcl_Obj *builtinArgumentPtr; /* the function arguments for builtin functions */
+    Tcl_Obj *origArgsPtr;       /* the argument string of the original definition */
+    Tcl_Obj *bodyPtr;           /* the function body */
+    ItclArgList *argListPtr;    /* the parsed arguments */
+    ItclClass *declaringClassPtr; /* the class which declared the method/proc */
+    void *tmPtr;                /* TclOO methodPtr */
+    ItclDelegatedFunction *idmPtr;
+                                /* if the function is delegated != NULL */
+} ItclMemberFunc;
+
+/*
+ *  Instance variables.
+ */
+typedef struct ItclVariable {
+    Tcl_Obj *namePtr;           /* member name */
+    Tcl_Obj *fullNamePtr;       /* member name with "class::" qualifier */
+    ItclClass *iclsPtr;         /* class containing this member */
+    ItclObjectInfo *infoPtr;
+    ItclMemberCode *codePtr;    /* code associated with member */
+    Tcl_Obj *init;              /* initial value */
+    Tcl_Obj *arrayInitPtr;      /* initial value if variable should be array */
+    int protection;             /* protection level */
+    int flags;                  /* flags describing member (see below) */
+    int initted;                /* is set when first time initted, to check
+                                 * for example itcl_hull var, which can be only
+				 * initialized once */
+} ItclVariable;
+
+
+struct ItclOption;
+
+typedef struct ItclDelegatedOption {
+    Tcl_Obj *namePtr;
+    Tcl_Obj *resourceNamePtr;
+    Tcl_Obj *classNamePtr;
+    struct ItclOption *ioptPtr;  /* the option name or null for "*" */
+    ItclComponent *icPtr;        /* the component where the delegation goes
+                                  * to */
+    Tcl_Obj *asPtr;
+    Tcl_HashTable exceptions;    /* exceptions from delegation */
+} ItclDelegatedOption;
+
+/*
+ *  Instance options.
+ */
+typedef struct ItclOption {
+                                /* within a class hierarchy there must be only
+				 * one option with the same name !! */
+    Tcl_Obj *namePtr;           /* member name */
+    Tcl_Obj *fullNamePtr;       /* member name with "class::" qualifier */
+    Tcl_Obj *resourceNamePtr;
+    Tcl_Obj *classNamePtr;
+    ItclClass *iclsPtr;         /* class containing this member */
+    int protection;             /* protection level */
+    int flags;                  /* flags describing member (see below) */
+    ItclMemberCode *codePtr;    /* code associated with member */
+    Tcl_Obj *defaultValuePtr;   /* initial value */
+    Tcl_Obj *cgetMethodPtr;
+    Tcl_Obj *cgetMethodVarPtr;
+    Tcl_Obj *configureMethodPtr;
+    Tcl_Obj *configureMethodVarPtr;
+    Tcl_Obj *validateMethodPtr;
+    Tcl_Obj *validateMethodVarPtr;
+    ItclDelegatedOption *idoPtr;
+                                /* if the option is delegated != NULL */
+} ItclOption;
+
+/*
+ *  Instance methodvariables.
+ */
+typedef struct ItclMethodVariable {
+    Tcl_Obj *namePtr;           /* member name */
+    Tcl_Obj *fullNamePtr;       /* member name with "class::" qualifier */
+    ItclClass *iclsPtr;         /* class containing this member */
+    int protection;             /* protection level */
+    int flags;                  /* flags describing member (see below) */
+    Tcl_Obj *defaultValuePtr;
+    Tcl_Obj *callbackPtr;
+} ItclMethodVariable;
+
+#define VAR_TYPE_VARIABLE 	1
+#define VAR_TYPE_COMMON 	2
+
+#define CMD_TYPE_METHOD 	1
+#define CMD_TYPE_PROC 		2
+
+typedef struct ItclClassCmdInfo {
+    int type;
+    int protection;
+#if TCL_MAJOR_VERSION == 8
+    int cmdNum; /* not actually used */
+#endif
+    Tcl_Namespace *nsPtr;
+    Tcl_Namespace *declaringNsPtr;
+} ItclClassCmdInfo;
+
+/*
+ *  Instance variable lookup entry.
+ */
+typedef struct ItclVarLookup {
+    ItclVariable* ivPtr;      /* variable definition */
+    int usage;                /* number of uses for this record */
+    int accessible;           /* non-zero => accessible from class with
+                               * this lookup record in its resolveVars */
+    char *leastQualName;      /* simplist name for this variable, with
+                               * the fewest qualifiers.  This string is
+                               * taken from the resolveVars table, so
+                               * it shouldn't be freed. */
+    Tcl_Size varNum;
+    Tcl_Var varPtr;
+} ItclVarLookup;
+
+/*
+ *  Instance command lookup entry.
+ */
+typedef struct ItclCmdLookup {
+    ItclMemberFunc* imPtr;    /* function definition */
+#if TCL_MAJOR_VERSION == 8
+    int cmdNum; /* not actually used */
+#endif
+    ItclClassCmdInfo *classCmdInfoPtr;
+    Tcl_Command cmdPtr;
+} ItclCmdLookup;
+
+typedef struct ItclCallContext {
+    int objectFlags;
+    Tcl_Namespace *nsPtr;
+    ItclObject *ioPtr;
+    ItclMemberFunc *imPtr;
+    Tcl_Size refCount;
+} ItclCallContext;
+
+/*
+ * The macro below is used to modify a "char" value (e.g. by casting
+ * it to an unsigned character) so that it can be used safely with
+ * macros such as isspace.
+ */
+
+#define UCHAR(c) ((unsigned char) (c))
+/*
+ * Macros used to cast between pointers and integers (e.g. when storing an int
+ * in ClientData), on 64-bit architectures they avoid gcc warning about "cast
+ * to/from pointer from/to integer of different size".
+ */
+
+#if !defined(INT2PTR)
+#   define INT2PTR(p) ((void *)(ptrdiff_t)(p))
+#endif
+#if !defined(PTR2INT)
+#   define PTR2INT(p) ((ptrdiff_t)(p))
+#endif
+
+#ifdef ITCL_DEBUG
+MODULE_SCOPE int _itcl_debug_level;
+MODULE_SCOPE void ItclShowArgs(int level, const char *str, size_t objc,
+	Tcl_Obj *const *objv);
+#else
+#define ItclShowArgs(a,b,c,d) do {(void)(c);(void)(d);} while(0)
+#endif
+
+MODULE_SCOPE Tcl_ObjCmdProc ItclCallCCommand;
+MODULE_SCOPE Tcl_ObjCmdProc ItclObjectUnknownCommand;
+MODULE_SCOPE int ItclCheckCallProc(void *clientData, Tcl_Interp *interp,
+	Tcl_ObjectContext contextPtr, Tcl_CallFrame *framePtr, int *isFinished);
+
+MODULE_SCOPE void ItclPreserveClass(ItclClass *iclsPtr);
+MODULE_SCOPE void ItclReleaseClass(void *iclsPtr);
+
+MODULE_SCOPE ItclFoundation *ItclGetFoundation(Tcl_Interp *interp);
+MODULE_SCOPE Tcl_ObjCmdProc ItclClassCommandDispatcher;
+MODULE_SCOPE Tcl_Command Itcl_CmdAliasProc(Tcl_Interp *interp,
+	Tcl_Namespace *nsPtr, const char *cmdName, void *clientData);
+MODULE_SCOPE Tcl_Var Itcl_VarAliasProc(Tcl_Interp *interp,
+	Tcl_Namespace *nsPtr, const char *VarName, void *clientData);
+MODULE_SCOPE int ItclIsClass(Tcl_Interp *interp, Tcl_Command cmd);
+MODULE_SCOPE int ItclCheckCallMethod(void *clientData, Tcl_Interp *interp,
+	Tcl_ObjectContext contextPtr, Tcl_CallFrame *framePtr, int *isFinished);
+MODULE_SCOPE int ItclAfterCallMethod(void *clientData, Tcl_Interp *interp,
+	Tcl_ObjectContext contextPtr, Tcl_Namespace *nsPtr, int result);
+MODULE_SCOPE void ItclReportObjectUsage(Tcl_Interp *interp,
+	ItclObject *contextIoPtr, Tcl_Namespace *callerNsPtr,
+	Tcl_Namespace *contextNsPtr);
+MODULE_SCOPE int ItclMapMethodNameProc(Tcl_Interp *interp, Tcl_Object oPtr,
+	Tcl_Class *startClsPtr, Tcl_Obj *methodObj);
+MODULE_SCOPE int ItclCreateArgList(Tcl_Interp *interp, const char *str,
+	Tcl_Size *argcPtr, Tcl_Size *maxArgcPtr, Tcl_Obj **usagePtr,
+	ItclArgList **arglistPtrPtr, ItclMemberFunc *imPtr,
+	const char *commandName);
+MODULE_SCOPE int ItclObjectCmd(void *clientData, Tcl_Interp *interp,
+	Tcl_Object oPtr, Tcl_Class clsPtr, size_t objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int ItclCreateObject (Tcl_Interp *interp, const char* name,
+	ItclClass *iclsPtr, size_t objc, Tcl_Obj *const objv[]);
+MODULE_SCOPE void ItclDeleteObjectVariablesNamespace(Tcl_Interp *interp,
+	ItclObject *ioPtr);
+MODULE_SCOPE void ItclDeleteClassVariablesNamespace(Tcl_Interp *interp,
+	ItclClass *iclsPtr);
+MODULE_SCOPE int ItclInfoInit(Tcl_Interp *interp, ItclObjectInfo *infoPtr);
+
+MODULE_SCOPE Tcl_HashEntry *ItclResolveVarEntry(
+	ItclClass* iclsPtr, const char *varName);
+
+struct Tcl_ResolvedVarInfo;
+MODULE_SCOPE int Itcl_ClassCmdResolver(Tcl_Interp *interp, const char* name,
+	Tcl_Namespace *nsPtr, int flags, Tcl_Command *rPtr);
+MODULE_SCOPE int Itcl_ClassVarResolver(Tcl_Interp *interp, const char* name,
+	Tcl_Namespace *nsPtr, int flags, Tcl_Var *rPtr);
+MODULE_SCOPE int Itcl_ClassCompiledVarResolver(Tcl_Interp *interp,
+	const char* name, Tcl_Size length, Tcl_Namespace *nsPtr,
+	struct Tcl_ResolvedVarInfo **rPtr);
+MODULE_SCOPE int Itcl_ClassCmdResolver2(Tcl_Interp *interp, const char* name,
+	Tcl_Namespace *nsPtr, int flags, Tcl_Command *rPtr);
+MODULE_SCOPE int Itcl_ClassVarResolver2(Tcl_Interp *interp, const char* name,
+	Tcl_Namespace *nsPtr, int flags, Tcl_Var *rPtr);
+MODULE_SCOPE int ItclSetParserResolver(Tcl_Namespace *nsPtr);
+MODULE_SCOPE void ItclProcErrorProc(Tcl_Interp *interp, Tcl_Obj *procNameObj);
+MODULE_SCOPE int Itcl_CreateOption (Tcl_Interp *interp, ItclClass *iclsPtr,
+	ItclOption *ioptPtr);
+MODULE_SCOPE int ItclCreateMethodVariable(Tcl_Interp *interp,
+	ItclVariable *ivPtr, Tcl_Obj* defaultPtr, Tcl_Obj* callbackPtr,
+	ItclMethodVariable** imvPtrPtr);
+MODULE_SCOPE int DelegationInstall(Tcl_Interp *interp, ItclObject *ioPtr,
+	ItclClass *iclsPtr);
+MODULE_SCOPE ItclClass *ItclNamespace2Class(Tcl_Namespace *nsPtr);
+MODULE_SCOPE const char* ItclGetCommonInstanceVar(Tcl_Interp *interp,
+	const char *name, const char *name2, ItclObject *contextIoPtr,
+	ItclClass *contextIclsPtr);
+MODULE_SCOPE int ItclCreateMethod(Tcl_Interp* interp, ItclClass *iclsPtr,
+	Tcl_Obj *namePtr, const char* arglist, const char* body,
+	ItclMemberFunc **imPtrPtr);
+MODULE_SCOPE int Itcl_WidgetParseInit(Tcl_Interp *interp,
+	ItclObjectInfo *infoPtr);
+MODULE_SCOPE void ItclDeleteObjectMetadata(void *clientData);
+MODULE_SCOPE void ItclDeleteClassMetadata(void *clientData);
+MODULE_SCOPE void ItclDeleteArgList(ItclArgList *arglistPtr);
+MODULE_SCOPE int Itcl_ClassOptionCmd(void *clientData, Tcl_Interp *interp,
+	int objc, Tcl_Obj *const objv[]);
+MODULE_SCOPE int DelegatedOptionsInstall(Tcl_Interp *interp,
+	ItclClass *iclsPtr);
+MODULE_SCOPE int Itcl_HandleDelegateOptionCmd(Tcl_Interp *interp,
+	ItclObject *ioPtr, ItclClass *iclsPtr, ItclDelegatedOption **idoPtrPtr,
+	Tcl_Size objc, Tcl_Obj *const objv[]);
+MODULE_SCOPE int Itcl_HandleDelegateMethodCmd(Tcl_Interp *interp,
+	ItclObject *ioPtr, ItclClass *iclsPtr,
+	ItclDelegatedFunction **idmPtrPtr, Tcl_Size objc, Tcl_Obj *const objv[]);
+MODULE_SCOPE int DelegateFunction(Tcl_Interp *interp, ItclObject *ioPtr,
+	ItclClass *iclsPtr, Tcl_Obj *componentNamePtr,
+	ItclDelegatedFunction *idmPtr);
+MODULE_SCOPE int ItclInitObjectMethodVariables(Tcl_Interp *interp,
+	ItclObject *ioPtr, ItclClass *iclsPtr, const char *name);
+MODULE_SCOPE int InitTclOOFunctionPointers(Tcl_Interp *interp);
+MODULE_SCOPE ItclOption* ItclNewOption(Tcl_Interp *interp, ItclObject *ioPtr,
+	ItclClass *iclsPtr, Tcl_Obj *namePtr, const char *resourceName,
+	const char *className, char *init, ItclMemberCode *mCodePtr);
+MODULE_SCOPE int ItclParseOption(ItclObjectInfo *infoPtr, Tcl_Interp *interp,
+	size_t objc, Tcl_Obj *const objv[], ItclClass *iclsPtr,
+	ItclObject *ioPtr, ItclOption **ioptPtrPtr);
+MODULE_SCOPE void ItclDestroyClassNamesp(void *cdata);
+MODULE_SCOPE int ExpandDelegateAs(Tcl_Interp *interp, ItclObject *ioPtr,
+	ItclClass *iclsPtr, ItclDelegatedFunction *idmPtr,
+	const char *funcName, Tcl_Obj *listPtr);
+MODULE_SCOPE int ItclCheckForInitializedComponents(Tcl_Interp *interp,
+	ItclClass *iclsPtr, ItclObject *ioPtr);
+MODULE_SCOPE int ItclCreateDelegatedFunction(Tcl_Interp *interp,
+	ItclClass *iclsPtr, Tcl_Obj *methodNamePtr, ItclComponent *icPtr,
+	Tcl_Obj *targetPtr, Tcl_Obj *usingPtr, Tcl_Obj *exceptionsPtr,
+	ItclDelegatedFunction **idmPtrPtr);
+MODULE_SCOPE void ItclDeleteDelegatedOption(char *cdata);
+MODULE_SCOPE void Itcl_FinishList();
+MODULE_SCOPE void ItclDeleteDelegatedFunction(ItclDelegatedFunction *idmPtr);
+MODULE_SCOPE void ItclFinishEnsemble(ItclObjectInfo *infoPtr);
+MODULE_SCOPE int Itcl_EnsembleDeleteCmd(void *clientData,
+	Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
+MODULE_SCOPE int ItclAddClassesDictInfo(Tcl_Interp *interp, ItclClass *iclsPtr);
+MODULE_SCOPE int ItclDeleteClassesDictInfo(Tcl_Interp *interp,
+	ItclClass *iclsPtr);
+MODULE_SCOPE int ItclAddObjectsDictInfo(Tcl_Interp *interp, ItclObject *ioPtr);
+MODULE_SCOPE int ItclDeleteObjectsDictInfo(Tcl_Interp *interp,
+	ItclObject *ioPtr);
+MODULE_SCOPE int ItclAddOptionDictInfo(Tcl_Interp *interp, ItclClass *iclsPtr,
+	ItclOption *ioptPtr);
+MODULE_SCOPE int ItclAddDelegatedOptionDictInfo(Tcl_Interp *interp,
+	ItclClass *iclsPtr, ItclDelegatedOption *idoPtr);
+MODULE_SCOPE int ItclAddClassComponentDictInfo(Tcl_Interp *interp,
+	ItclClass *iclsPtr, ItclComponent *icPtr);
+MODULE_SCOPE int ItclAddClassVariableDictInfo(Tcl_Interp *interp,
+	ItclClass *iclsPtr, ItclVariable *ivPtr);
+MODULE_SCOPE int ItclAddClassFunctionDictInfo(Tcl_Interp *interp,
+	ItclClass *iclsPtr, ItclMemberFunc *imPtr);
+MODULE_SCOPE int ItclAddClassDelegatedFunctionDictInfo(Tcl_Interp *interp,
+	ItclClass *iclsPtr, ItclDelegatedFunction *idmPtr);
+MODULE_SCOPE int ItclClassCreateObject(void *clientData, Tcl_Interp *interp,
+	Tcl_Size objc, Tcl_Obj *const objv[]);
+
+MODULE_SCOPE void ItclRestoreInfoVars(void *clientData);
+
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiMyProcCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiInstallComponentCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiCallInstanceCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiGetInstanceVarCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiMyTypeMethodCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiMyMethodCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiMyTypeVarCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiMyVarCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_BiItclHullCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_ThisCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_ExtendedClassCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_TypeClassCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_AddObjectOptionCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_AddDelegatedOptionCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_AddDelegatedFunctionCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_SetComponentCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_ClassHullTypeCmd;
+MODULE_SCOPE Tcl_ObjCmdProc Itcl_ClassWidgetClassCmd;
+
+typedef int (ItclRootMethodProc)(ItclObject *ioPtr, Tcl_Interp *interp,
+	int objc, Tcl_Obj *const objv[]);
+
+MODULE_SCOPE const Tcl_MethodType itclRootMethodType;
+MODULE_SCOPE ItclRootMethodProc ItclUnknownGuts;
+MODULE_SCOPE ItclRootMethodProc ItclConstructGuts;
+MODULE_SCOPE ItclRootMethodProc ItclInfoGuts;
+
+#include "itcl2TclOO.h"
+
+/*
+ * Include all the private API, generated from itcl.decls.
+ */
+
+#include "itclIntDecls.h"

llava_next/include/tclOOIntDecls.h

@@ -0,0 +1,166 @@
+/*
+ * This file is (mostly) automatically generated from tclOO.decls.
+ */
+
+#ifndef _TCLOOINTDECLS
+#define _TCLOOINTDECLS
+
+/* !BEGIN!: Do not edit below this line. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Exported function declarations:
+ */
+
+/* 0 */
+TCLAPI Tcl_Object	TclOOGetDefineCmdContext(Tcl_Interp *interp);
+/* 1 */
+TCLAPI Tcl_Method	TclOOMakeProcInstanceMethod(Tcl_Interp *interp,
+				Object *oPtr, int flags, Tcl_Obj *nameObj,
+				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
+				const Tcl_MethodType *typePtr,
+				void *clientData, Proc **procPtrPtr);
+/* 2 */
+TCLAPI Tcl_Method	TclOOMakeProcMethod(Tcl_Interp *interp,
+				Class *clsPtr, int flags, Tcl_Obj *nameObj,
+				const char *namePtr, Tcl_Obj *argsObj,
+				Tcl_Obj *bodyObj,
+				const Tcl_MethodType *typePtr,
+				void *clientData, Proc **procPtrPtr);
+/* 3 */
+TCLAPI Method *		TclOONewProcInstanceMethod(Tcl_Interp *interp,
+				Object *oPtr, int flags, Tcl_Obj *nameObj,
+				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
+				ProcedureMethod **pmPtrPtr);
+/* 4 */
+TCLAPI Method *		TclOONewProcMethod(Tcl_Interp *interp, Class *clsPtr,
+				int flags, Tcl_Obj *nameObj,
+				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
+				ProcedureMethod **pmPtrPtr);
+/* 5 */
+TCLAPI int		TclOOObjectCmdCore(Object *oPtr, Tcl_Interp *interp,
+				int objc, Tcl_Obj *const *objv,
+				int publicOnly, Class *startCls);
+/* 6 */
+TCLAPI int		TclOOIsReachable(Class *targetPtr, Class *startPtr);
+/* 7 */
+TCLAPI Method *		TclOONewForwardMethod(Tcl_Interp *interp,
+				Class *clsPtr, int isPublic,
+				Tcl_Obj *nameObj, Tcl_Obj *prefixObj);
+/* 8 */
+TCLAPI Method *		TclOONewForwardInstanceMethod(Tcl_Interp *interp,
+				Object *oPtr, int isPublic, Tcl_Obj *nameObj,
+				Tcl_Obj *prefixObj);
+/* 9 */
+TCLAPI Tcl_Method	TclOONewProcInstanceMethodEx(Tcl_Interp *interp,
+				Tcl_Object oPtr,
+				TclOO_PreCallProc *preCallPtr,
+				TclOO_PostCallProc *postCallPtr,
+				ProcErrorProc *errProc, void *clientData,
+				Tcl_Obj *nameObj, Tcl_Obj *argsObj,
+				Tcl_Obj *bodyObj, int flags,
+				void **internalTokenPtr);
+/* 10 */
+TCLAPI Tcl_Method	TclOONewProcMethodEx(Tcl_Interp *interp,
+				Tcl_Class clsPtr,
+				TclOO_PreCallProc *preCallPtr,
+				TclOO_PostCallProc *postCallPtr,
+				ProcErrorProc *errProc, void *clientData,
+				Tcl_Obj *nameObj, Tcl_Obj *argsObj,
+				Tcl_Obj *bodyObj, int flags,
+				void **internalTokenPtr);
+/* 11 */
+TCLAPI int		TclOOInvokeObject(Tcl_Interp *interp,
+				Tcl_Object object, Tcl_Class startCls,
+				int publicPrivate, int objc,
+				Tcl_Obj *const *objv);
+/* 12 */
+TCLAPI void		TclOOObjectSetFilters(Object *oPtr, int numFilters,
+				Tcl_Obj *const *filters);
+/* 13 */
+TCLAPI void		TclOOClassSetFilters(Tcl_Interp *interp,
+				Class *classPtr, int numFilters,
+				Tcl_Obj *const *filters);
+/* 14 */
+TCLAPI void		TclOOObjectSetMixins(Object *oPtr, int numMixins,
+				Class *const *mixins);
+/* 15 */
+TCLAPI void		TclOOClassSetMixins(Tcl_Interp *interp,
+				Class *classPtr, int numMixins,
+				Class *const *mixins);
+
+typedef struct TclOOIntStubs {
+    int magic;
+    void *hooks;
+
+    Tcl_Object (*tclOOGetDefineCmdContext) (Tcl_Interp *interp); /* 0 */
+    Tcl_Method (*tclOOMakeProcInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, void *clientData, Proc **procPtrPtr); /* 1 */
+    Tcl_Method (*tclOOMakeProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, const char *namePtr, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, void *clientData, Proc **procPtrPtr); /* 2 */
+    Method * (*tclOONewProcInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, ProcedureMethod **pmPtrPtr); /* 3 */
+    Method * (*tclOONewProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, ProcedureMethod **pmPtrPtr); /* 4 */
+    int (*tclOOObjectCmdCore) (Object *oPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, int publicOnly, Class *startCls); /* 5 */
+    int (*tclOOIsReachable) (Class *targetPtr, Class *startPtr); /* 6 */
+    Method * (*tclOONewForwardMethod) (Tcl_Interp *interp, Class *clsPtr, int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj); /* 7 */
+    Method * (*tclOONewForwardInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj); /* 8 */
+    Tcl_Method (*tclOONewProcInstanceMethodEx) (Tcl_Interp *interp, Tcl_Object oPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 9 */
+    Tcl_Method (*tclOONewProcMethodEx) (Tcl_Interp *interp, Tcl_Class clsPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 10 */
+    int (*tclOOInvokeObject) (Tcl_Interp *interp, Tcl_Object object, Tcl_Class startCls, int publicPrivate, int objc, Tcl_Obj *const *objv); /* 11 */
+    void (*tclOOObjectSetFilters) (Object *oPtr, int numFilters, Tcl_Obj *const *filters); /* 12 */
+    void (*tclOOClassSetFilters) (Tcl_Interp *interp, Class *classPtr, int numFilters, Tcl_Obj *const *filters); /* 13 */
+    void (*tclOOObjectSetMixins) (Object *oPtr, int numMixins, Class *const *mixins); /* 14 */
+    void (*tclOOClassSetMixins) (Tcl_Interp *interp, Class *classPtr, int numMixins, Class *const *mixins); /* 15 */
+} TclOOIntStubs;
+
+extern const TclOOIntStubs *tclOOIntStubsPtr;
+
+#ifdef __cplusplus
+}
+#endif
+
+#if defined(USE_TCLOO_STUBS)
+
+/*
+ * Inline function declarations:
+ */
+
+#define TclOOGetDefineCmdContext \
+	(tclOOIntStubsPtr->tclOOGetDefineCmdContext) /* 0 */
+#define TclOOMakeProcInstanceMethod \
+	(tclOOIntStubsPtr->tclOOMakeProcInstanceMethod) /* 1 */
+#define TclOOMakeProcMethod \
+	(tclOOIntStubsPtr->tclOOMakeProcMethod) /* 2 */
+#define TclOONewProcInstanceMethod \
+	(tclOOIntStubsPtr->tclOONewProcInstanceMethod) /* 3 */
+#define TclOONewProcMethod \
+	(tclOOIntStubsPtr->tclOONewProcMethod) /* 4 */
+#define TclOOObjectCmdCore \
+	(tclOOIntStubsPtr->tclOOObjectCmdCore) /* 5 */
+#define TclOOIsReachable \
+	(tclOOIntStubsPtr->tclOOIsReachable) /* 6 */
+#define TclOONewForwardMethod \
+	(tclOOIntStubsPtr->tclOONewForwardMethod) /* 7 */
+#define TclOONewForwardInstanceMethod \
+	(tclOOIntStubsPtr->tclOONewForwardInstanceMethod) /* 8 */
+#define TclOONewProcInstanceMethodEx \
+	(tclOOIntStubsPtr->tclOONewProcInstanceMethodEx) /* 9 */
+#define TclOONewProcMethodEx \
+	(tclOOIntStubsPtr->tclOONewProcMethodEx) /* 10 */
+#define TclOOInvokeObject \
+	(tclOOIntStubsPtr->tclOOInvokeObject) /* 11 */
+#define TclOOObjectSetFilters \
+	(tclOOIntStubsPtr->tclOOObjectSetFilters) /* 12 */
+#define TclOOClassSetFilters \
+	(tclOOIntStubsPtr->tclOOClassSetFilters) /* 13 */
+#define TclOOObjectSetMixins \
+	(tclOOIntStubsPtr->tclOOObjectSetMixins) /* 14 */
+#define TclOOClassSetMixins \
+	(tclOOIntStubsPtr->tclOOClassSetMixins) /* 15 */
+
+#endif /* defined(USE_TCLOO_STUBS) */
+
+/* !END!: Do not edit above this line. */
+
+#endif /* _TCLOOINTDECLS */

llava_next/include/term.h

@@ -0,0 +1,893 @@
+/****************************************************************************
+ * Copyright 2018-2020,2021 Thomas E. Dickey                                *
+ * Copyright 1998-2013,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************/
+/* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995                */
+/*    and: Eric S. Raymond <esr@snark.thyrsus.com>                          */
+/*    and: Thomas E. Dickey                        1995-on                  */
+/****************************************************************************/
+
+/* $Id: MKterm.h.awk.in,v 1.82 2021/09/24 17:02:46 tom Exp $ */
+
+/*
+**	term.h -- Definition of struct term
+*/
+
+#ifndef NCURSES_TERM_H_incl
+#define NCURSES_TERM_H_incl 1
+
+#undef  NCURSES_VERSION
+#define NCURSES_VERSION "6.4"
+
+#include <ncursesw/ncurses_dll.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Make this file self-contained by providing defaults for the HAVE_TERMIO[S]_H
+ * definition (based on the system for which this was configured).
+ */
+
+#ifndef __NCURSES_H
+
+typedef struct screen  SCREEN;
+
+#if 1
+#undef  NCURSES_SP_FUNCS
+#define NCURSES_SP_FUNCS 20221231
+#undef  NCURSES_SP_NAME
+#define NCURSES_SP_NAME(name) name##_sp
+
+/* Define the sp-funcs helper function */
+#undef  NCURSES_SP_OUTC
+#define NCURSES_SP_OUTC NCURSES_SP_NAME(NCURSES_OUTC)
+typedef int (*NCURSES_SP_OUTC)(SCREEN*, int);
+#endif
+
+#endif /* __NCURSES_H */
+
+#undef  NCURSES_CONST
+#define NCURSES_CONST const
+
+#undef  NCURSES_SBOOL
+#define NCURSES_SBOOL char
+
+#undef  NCURSES_USE_DATABASE
+#define NCURSES_USE_DATABASE 1
+
+#undef  NCURSES_USE_TERMCAP
+#define NCURSES_USE_TERMCAP 1
+
+#undef  NCURSES_XNAMES
+#define NCURSES_XNAMES 1
+
+/* We will use these symbols to hide differences between
+ * termios/termio/sgttyb interfaces.
+ */
+#undef  TTY
+#undef  SET_TTY
+#undef  GET_TTY
+
+/* Assume POSIX termio if we have the header and function */
+/* #if HAVE_TERMIOS_H && HAVE_TCGETATTR */
+#if 1 && 1
+
+#undef  TERMIOS
+#define TERMIOS 1
+
+#include <termios.h>
+#define TTY struct termios
+
+#else /* !HAVE_TERMIOS_H */
+
+/* #if HAVE_TERMIO_H */
+#if 1
+
+#undef  TERMIOS
+#define TERMIOS 1
+
+#include <termio.h>
+#define TTY struct termio
+
+#else /* !HAVE_TERMIO_H */
+
+#if (defined(_WIN32) || defined(_WIN64))
+#if 0
+#include <ncursesw/win32_curses.h>
+#define TTY struct winconmode
+#else
+#include <ncursesw/ncurses_mingw.h>
+#define TTY struct termios
+#endif
+#else
+#undef TERMIOS
+#include <sgtty.h>
+#include <sys/ioctl.h>
+#define TTY struct sgttyb
+#endif /* MINGW32 */
+#endif /* HAVE_TERMIO_H */
+
+#endif /* HAVE_TERMIOS_H */
+
+#ifdef TERMIOS
+#define GET_TTY(fd, buf) tcgetattr(fd, buf)
+#define SET_TTY(fd, buf) tcsetattr(fd, TCSADRAIN, buf)
+#elif 0 && (defined(_WIN32) || defined(_WIN64))
+#define GET_TTY(fd, buf) _nc_console_getmode(_nc_console_fd2handle(fd),buf)
+#define SET_TTY(fd, buf) _nc_console_setmode(_nc_console_fd2handle(fd),buf)
+#else
+#define GET_TTY(fd, buf) gtty(fd, buf)
+#define SET_TTY(fd, buf) stty(fd, buf)
+#endif
+
+#ifndef	GCC_NORETURN
+#define	GCC_NORETURN /* nothing */
+#endif
+
+#define NAMESIZE 256
+
+/* The cast works because TERMTYPE is the first data in TERMINAL */
+#define CUR ((TERMTYPE *)(cur_term))->
+
+#define auto_left_margin               CUR Booleans[0]
+#define auto_right_margin              CUR Booleans[1]
+#define no_esc_ctlc                    CUR Booleans[2]
+#define ceol_standout_glitch           CUR Booleans[3]
+#define eat_newline_glitch             CUR Booleans[4]
+#define erase_overstrike               CUR Booleans[5]
+#define generic_type                   CUR Booleans[6]
+#define hard_copy                      CUR Booleans[7]
+#define has_meta_key                   CUR Booleans[8]
+#define has_status_line                CUR Booleans[9]
+#define insert_null_glitch             CUR Booleans[10]
+#define memory_above                   CUR Booleans[11]
+#define memory_below                   CUR Booleans[12]
+#define move_insert_mode               CUR Booleans[13]
+#define move_standout_mode             CUR Booleans[14]
+#define over_strike                    CUR Booleans[15]
+#define status_line_esc_ok             CUR Booleans[16]
+#define dest_tabs_magic_smso           CUR Booleans[17]
+#define tilde_glitch                   CUR Booleans[18]
+#define transparent_underline          CUR Booleans[19]
+#define xon_xoff                       CUR Booleans[20]
+#define needs_xon_xoff                 CUR Booleans[21]
+#define prtr_silent                    CUR Booleans[22]
+#define hard_cursor                    CUR Booleans[23]
+#define non_rev_rmcup                  CUR Booleans[24]
+#define no_pad_char                    CUR Booleans[25]
+#define non_dest_scroll_region         CUR Booleans[26]
+#define can_change                     CUR Booleans[27]
+#define back_color_erase               CUR Booleans[28]
+#define hue_lightness_saturation       CUR Booleans[29]
+#define col_addr_glitch                CUR Booleans[30]
+#define cr_cancels_micro_mode          CUR Booleans[31]
+#define has_print_wheel                CUR Booleans[32]
+#define row_addr_glitch                CUR Booleans[33]
+#define semi_auto_right_margin         CUR Booleans[34]
+#define cpi_changes_res                CUR Booleans[35]
+#define lpi_changes_res                CUR Booleans[36]
+#define columns                        CUR Numbers[0]
+#define init_tabs                      CUR Numbers[1]
+#define lines                          CUR Numbers[2]
+#define lines_of_memory                CUR Numbers[3]
+#define magic_cookie_glitch            CUR Numbers[4]
+#define padding_baud_rate              CUR Numbers[5]
+#define virtual_terminal               CUR Numbers[6]
+#define width_status_line              CUR Numbers[7]
+#define num_labels                     CUR Numbers[8]
+#define label_height                   CUR Numbers[9]
+#define label_width                    CUR Numbers[10]
+#define max_attributes                 CUR Numbers[11]
+#define maximum_windows                CUR Numbers[12]
+#define max_colors                     CUR Numbers[13]
+#define max_pairs                      CUR Numbers[14]
+#define no_color_video                 CUR Numbers[15]
+#define buffer_capacity                CUR Numbers[16]
+#define dot_vert_spacing               CUR Numbers[17]
+#define dot_horz_spacing               CUR Numbers[18]
+#define max_micro_address              CUR Numbers[19]
+#define max_micro_jump                 CUR Numbers[20]
+#define micro_col_size                 CUR Numbers[21]
+#define micro_line_size                CUR Numbers[22]
+#define number_of_pins                 CUR Numbers[23]
+#define output_res_char                CUR Numbers[24]
+#define output_res_line                CUR Numbers[25]
+#define output_res_horz_inch           CUR Numbers[26]
+#define output_res_vert_inch           CUR Numbers[27]
+#define print_rate                     CUR Numbers[28]
+#define wide_char_size                 CUR Numbers[29]
+#define buttons                        CUR Numbers[30]
+#define bit_image_entwining            CUR Numbers[31]
+#define bit_image_type                 CUR Numbers[32]
+#define back_tab                       CUR Strings[0]
+#define bell                           CUR Strings[1]
+#define carriage_return                CUR Strings[2]
+#define change_scroll_region           CUR Strings[3]
+#define clear_all_tabs                 CUR Strings[4]
+#define clear_screen                   CUR Strings[5]
+#define clr_eol                        CUR Strings[6]
+#define clr_eos                        CUR Strings[7]
+#define column_address                 CUR Strings[8]
+#define command_character              CUR Strings[9]
+#define cursor_address                 CUR Strings[10]
+#define cursor_down                    CUR Strings[11]
+#define cursor_home                    CUR Strings[12]
+#define cursor_invisible               CUR Strings[13]
+#define cursor_left                    CUR Strings[14]
+#define cursor_mem_address             CUR Strings[15]
+#define cursor_normal                  CUR Strings[16]
+#define cursor_right                   CUR Strings[17]
+#define cursor_to_ll                   CUR Strings[18]
+#define cursor_up                      CUR Strings[19]
+#define cursor_visible                 CUR Strings[20]
+#define delete_character               CUR Strings[21]
+#define delete_line                    CUR Strings[22]
+#define dis_status_line                CUR Strings[23]
+#define down_half_line                 CUR Strings[24]
+#define enter_alt_charset_mode         CUR Strings[25]
+#define enter_blink_mode               CUR Strings[26]
+#define enter_bold_mode                CUR Strings[27]
+#define enter_ca_mode                  CUR Strings[28]
+#define enter_delete_mode              CUR Strings[29]
+#define enter_dim_mode                 CUR Strings[30]
+#define enter_insert_mode              CUR Strings[31]
+#define enter_secure_mode              CUR Strings[32]
+#define enter_protected_mode           CUR Strings[33]
+#define enter_reverse_mode             CUR Strings[34]
+#define enter_standout_mode            CUR Strings[35]
+#define enter_underline_mode           CUR Strings[36]
+#define erase_chars                    CUR Strings[37]
+#define exit_alt_charset_mode          CUR Strings[38]
+#define exit_attribute_mode            CUR Strings[39]
+#define exit_ca_mode                   CUR Strings[40]
+#define exit_delete_mode               CUR Strings[41]
+#define exit_insert_mode               CUR Strings[42]
+#define exit_standout_mode             CUR Strings[43]
+#define exit_underline_mode            CUR Strings[44]
+#define flash_screen                   CUR Strings[45]
+#define form_feed                      CUR Strings[46]
+#define from_status_line               CUR Strings[47]
+#define init_1string                   CUR Strings[48]
+#define init_2string                   CUR Strings[49]
+#define init_3string                   CUR Strings[50]
+#define init_file                      CUR Strings[51]
+#define insert_character               CUR Strings[52]
+#define insert_line                    CUR Strings[53]
+#define insert_padding                 CUR Strings[54]
+#define key_backspace                  CUR Strings[55]
+#define key_catab                      CUR Strings[56]
+#define key_clear                      CUR Strings[57]
+#define key_ctab                       CUR Strings[58]
+#define key_dc                         CUR Strings[59]
+#define key_dl                         CUR Strings[60]
+#define key_down                       CUR Strings[61]
+#define key_eic                        CUR Strings[62]
+#define key_eol                        CUR Strings[63]
+#define key_eos                        CUR Strings[64]
+#define key_f0                         CUR Strings[65]
+#define key_f1                         CUR Strings[66]
+#define key_f10                        CUR Strings[67]
+#define key_f2                         CUR Strings[68]
+#define key_f3                         CUR Strings[69]
+#define key_f4                         CUR Strings[70]
+#define key_f5                         CUR Strings[71]
+#define key_f6                         CUR Strings[72]
+#define key_f7                         CUR Strings[73]
+#define key_f8                         CUR Strings[74]
+#define key_f9                         CUR Strings[75]
+#define key_home                       CUR Strings[76]
+#define key_ic                         CUR Strings[77]
+#define key_il                         CUR Strings[78]
+#define key_left                       CUR Strings[79]
+#define key_ll                         CUR Strings[80]
+#define key_npage                      CUR Strings[81]
+#define key_ppage                      CUR Strings[82]
+#define key_right                      CUR Strings[83]
+#define key_sf                         CUR Strings[84]
+#define key_sr                         CUR Strings[85]
+#define key_stab                       CUR Strings[86]
+#define key_up                         CUR Strings[87]
+#define keypad_local                   CUR Strings[88]
+#define keypad_xmit                    CUR Strings[89]
+#define lab_f0                         CUR Strings[90]
+#define lab_f1                         CUR Strings[91]
+#define lab_f10                        CUR Strings[92]
+#define lab_f2                         CUR Strings[93]
+#define lab_f3                         CUR Strings[94]
+#define lab_f4                         CUR Strings[95]
+#define lab_f5                         CUR Strings[96]
+#define lab_f6                         CUR Strings[97]
+#define lab_f7                         CUR Strings[98]
+#define lab_f8                         CUR Strings[99]
+#define lab_f9                         CUR Strings[100]
+#define meta_off                       CUR Strings[101]
+#define meta_on                        CUR Strings[102]
+#define newline                        CUR Strings[103]
+#define pad_char                       CUR Strings[104]
+#define parm_dch                       CUR Strings[105]
+#define parm_delete_line               CUR Strings[106]
+#define parm_down_cursor               CUR Strings[107]
+#define parm_ich                       CUR Strings[108]
+#define parm_index                     CUR Strings[109]
+#define parm_insert_line               CUR Strings[110]
+#define parm_left_cursor               CUR Strings[111]
+#define parm_right_cursor              CUR Strings[112]
+#define parm_rindex                    CUR Strings[113]
+#define parm_up_cursor                 CUR Strings[114]
+#define pkey_key                       CUR Strings[115]
+#define pkey_local                     CUR Strings[116]
+#define pkey_xmit                      CUR Strings[117]
+#define print_screen                   CUR Strings[118]
+#define prtr_off                       CUR Strings[119]
+#define prtr_on                        CUR Strings[120]
+#define repeat_char                    CUR Strings[121]
+#define reset_1string                  CUR Strings[122]
+#define reset_2string                  CUR Strings[123]
+#define reset_3string                  CUR Strings[124]
+#define reset_file                     CUR Strings[125]
+#define restore_cursor                 CUR Strings[126]
+#define row_address                    CUR Strings[127]
+#define save_cursor                    CUR Strings[128]
+#define scroll_forward                 CUR Strings[129]
+#define scroll_reverse                 CUR Strings[130]
+#define set_attributes                 CUR Strings[131]
+#define set_tab                        CUR Strings[132]
+#define set_window                     CUR Strings[133]
+#define tab                            CUR Strings[134]
+#define to_status_line                 CUR Strings[135]
+#define underline_char                 CUR Strings[136]
+#define up_half_line                   CUR Strings[137]
+#define init_prog                      CUR Strings[138]
+#define key_a1                         CUR Strings[139]
+#define key_a3                         CUR Strings[140]
+#define key_b2                         CUR Strings[141]
+#define key_c1                         CUR Strings[142]
+#define key_c3                         CUR Strings[143]
+#define prtr_non                       CUR Strings[144]
+#define char_padding                   CUR Strings[145]
+#define acs_chars                      CUR Strings[146]
+#define plab_norm                      CUR Strings[147]
+#define key_btab                       CUR Strings[148]
+#define enter_xon_mode                 CUR Strings[149]
+#define exit_xon_mode                  CUR Strings[150]
+#define enter_am_mode                  CUR Strings[151]
+#define exit_am_mode                   CUR Strings[152]
+#define xon_character                  CUR Strings[153]
+#define xoff_character                 CUR Strings[154]
+#define ena_acs                        CUR Strings[155]
+#define label_on                       CUR Strings[156]
+#define label_off                      CUR Strings[157]
+#define key_beg                        CUR Strings[158]
+#define key_cancel                     CUR Strings[159]
+#define key_close                      CUR Strings[160]
+#define key_command                    CUR Strings[161]
+#define key_copy                       CUR Strings[162]
+#define key_create                     CUR Strings[163]
+#define key_end                        CUR Strings[164]
+#define key_enter                      CUR Strings[165]
+#define key_exit                       CUR Strings[166]
+#define key_find                       CUR Strings[167]
+#define key_help                       CUR Strings[168]
+#define key_mark                       CUR Strings[169]
+#define key_message                    CUR Strings[170]
+#define key_move                       CUR Strings[171]
+#define key_next                       CUR Strings[172]
+#define key_open                       CUR Strings[173]
+#define key_options                    CUR Strings[174]
+#define key_previous                   CUR Strings[175]
+#define key_print                      CUR Strings[176]
+#define key_redo                       CUR Strings[177]
+#define key_reference                  CUR Strings[178]
+#define key_refresh                    CUR Strings[179]
+#define key_replace                    CUR Strings[180]
+#define key_restart                    CUR Strings[181]
+#define key_resume                     CUR Strings[182]
+#define key_save                       CUR Strings[183]
+#define key_suspend                    CUR Strings[184]
+#define key_undo                       CUR Strings[185]
+#define key_sbeg                       CUR Strings[186]
+#define key_scancel                    CUR Strings[187]
+#define key_scommand                   CUR Strings[188]
+#define key_scopy                      CUR Strings[189]
+#define key_screate                    CUR Strings[190]
+#define key_sdc                        CUR Strings[191]
+#define key_sdl                        CUR Strings[192]
+#define key_select                     CUR Strings[193]
+#define key_send                       CUR Strings[194]
+#define key_seol                       CUR Strings[195]
+#define key_sexit                      CUR Strings[196]
+#define key_sfind                      CUR Strings[197]
+#define key_shelp                      CUR Strings[198]
+#define key_shome                      CUR Strings[199]
+#define key_sic                        CUR Strings[200]
+#define key_sleft                      CUR Strings[201]
+#define key_smessage                   CUR Strings[202]
+#define key_smove                      CUR Strings[203]
+#define key_snext                      CUR Strings[204]
+#define key_soptions                   CUR Strings[205]
+#define key_sprevious                  CUR Strings[206]
+#define key_sprint                     CUR Strings[207]
+#define key_sredo                      CUR Strings[208]
+#define key_sreplace                   CUR Strings[209]
+#define key_sright                     CUR Strings[210]
+#define key_srsume                     CUR Strings[211]
+#define key_ssave                      CUR Strings[212]
+#define key_ssuspend                   CUR Strings[213]
+#define key_sundo                      CUR Strings[214]
+#define req_for_input                  CUR Strings[215]
+#define key_f11                        CUR Strings[216]
+#define key_f12                        CUR Strings[217]
+#define key_f13                        CUR Strings[218]
+#define key_f14                        CUR Strings[219]
+#define key_f15                        CUR Strings[220]
+#define key_f16                        CUR Strings[221]
+#define key_f17                        CUR Strings[222]
+#define key_f18                        CUR Strings[223]
+#define key_f19                        CUR Strings[224]
+#define key_f20                        CUR Strings[225]
+#define key_f21                        CUR Strings[226]
+#define key_f22                        CUR Strings[227]
+#define key_f23                        CUR Strings[228]
+#define key_f24                        CUR Strings[229]
+#define key_f25                        CUR Strings[230]
+#define key_f26                        CUR Strings[231]
+#define key_f27                        CUR Strings[232]
+#define key_f28                        CUR Strings[233]
+#define key_f29                        CUR Strings[234]
+#define key_f30                        CUR Strings[235]
+#define key_f31                        CUR Strings[236]
+#define key_f32                        CUR Strings[237]
+#define key_f33                        CUR Strings[238]
+#define key_f34                        CUR Strings[239]
+#define key_f35                        CUR Strings[240]
+#define key_f36                        CUR Strings[241]
+#define key_f37                        CUR Strings[242]
+#define key_f38                        CUR Strings[243]
+#define key_f39                        CUR Strings[244]
+#define key_f40                        CUR Strings[245]
+#define key_f41                        CUR Strings[246]
+#define key_f42                        CUR Strings[247]
+#define key_f43                        CUR Strings[248]
+#define key_f44                        CUR Strings[249]
+#define key_f45                        CUR Strings[250]
+#define key_f46                        CUR Strings[251]
+#define key_f47                        CUR Strings[252]
+#define key_f48                        CUR Strings[253]
+#define key_f49                        CUR Strings[254]
+#define key_f50                        CUR Strings[255]
+#define key_f51                        CUR Strings[256]
+#define key_f52                        CUR Strings[257]
+#define key_f53                        CUR Strings[258]
+#define key_f54                        CUR Strings[259]
+#define key_f55                        CUR Strings[260]
+#define key_f56                        CUR Strings[261]
+#define key_f57                        CUR Strings[262]
+#define key_f58                        CUR Strings[263]
+#define key_f59                        CUR Strings[264]
+#define key_f60                        CUR Strings[265]
+#define key_f61                        CUR Strings[266]
+#define key_f62                        CUR Strings[267]
+#define key_f63                        CUR Strings[268]
+#define clr_bol                        CUR Strings[269]
+#define clear_margins                  CUR Strings[270]
+#define set_left_margin                CUR Strings[271]
+#define set_right_margin               CUR Strings[272]
+#define label_format                   CUR Strings[273]
+#define set_clock                      CUR Strings[274]
+#define display_clock                  CUR Strings[275]
+#define remove_clock                   CUR Strings[276]
+#define create_window                  CUR Strings[277]
+#define goto_window                    CUR Strings[278]
+#define hangup                         CUR Strings[279]
+#define dial_phone                     CUR Strings[280]
+#define quick_dial                     CUR Strings[281]
+#define tone                           CUR Strings[282]
+#define pulse                          CUR Strings[283]
+#define flash_hook                     CUR Strings[284]
+#define fixed_pause                    CUR Strings[285]
+#define wait_tone                      CUR Strings[286]
+#define user0                          CUR Strings[287]
+#define user1                          CUR Strings[288]
+#define user2                          CUR Strings[289]
+#define user3                          CUR Strings[290]
+#define user4                          CUR Strings[291]
+#define user5                          CUR Strings[292]
+#define user6                          CUR Strings[293]
+#define user7                          CUR Strings[294]
+#define user8                          CUR Strings[295]
+#define user9                          CUR Strings[296]
+#define orig_pair                      CUR Strings[297]
+#define orig_colors                    CUR Strings[298]
+#define initialize_color               CUR Strings[299]
+#define initialize_pair                CUR Strings[300]
+#define set_color_pair                 CUR Strings[301]
+#define set_foreground                 CUR Strings[302]
+#define set_background                 CUR Strings[303]
+#define change_char_pitch              CUR Strings[304]
+#define change_line_pitch              CUR Strings[305]
+#define change_res_horz                CUR Strings[306]
+#define change_res_vert                CUR Strings[307]
+#define define_char                    CUR Strings[308]
+#define enter_doublewide_mode          CUR Strings[309]
+#define enter_draft_quality            CUR Strings[310]
+#define enter_italics_mode             CUR Strings[311]
+#define enter_leftward_mode            CUR Strings[312]
+#define enter_micro_mode               CUR Strings[313]
+#define enter_near_letter_quality      CUR Strings[314]
+#define enter_normal_quality           CUR Strings[315]
+#define enter_shadow_mode              CUR Strings[316]
+#define enter_subscript_mode           CUR Strings[317]
+#define enter_superscript_mode         CUR Strings[318]
+#define enter_upward_mode              CUR Strings[319]
+#define exit_doublewide_mode           CUR Strings[320]
+#define exit_italics_mode              CUR Strings[321]
+#define exit_leftward_mode             CUR Strings[322]
+#define exit_micro_mode                CUR Strings[323]
+#define exit_shadow_mode               CUR Strings[324]
+#define exit_subscript_mode            CUR Strings[325]
+#define exit_superscript_mode          CUR Strings[326]
+#define exit_upward_mode               CUR Strings[327]
+#define micro_column_address           CUR Strings[328]
+#define micro_down                     CUR Strings[329]
+#define micro_left                     CUR Strings[330]
+#define micro_right                    CUR Strings[331]
+#define micro_row_address              CUR Strings[332]
+#define micro_up                       CUR Strings[333]
+#define order_of_pins                  CUR Strings[334]
+#define parm_down_micro                CUR Strings[335]
+#define parm_left_micro                CUR Strings[336]
+#define parm_right_micro               CUR Strings[337]
+#define parm_up_micro                  CUR Strings[338]
+#define select_char_set                CUR Strings[339]
+#define set_bottom_margin              CUR Strings[340]
+#define set_bottom_margin_parm         CUR Strings[341]
+#define set_left_margin_parm           CUR Strings[342]
+#define set_right_margin_parm          CUR Strings[343]
+#define set_top_margin                 CUR Strings[344]
+#define set_top_margin_parm            CUR Strings[345]
+#define start_bit_image                CUR Strings[346]
+#define start_char_set_def             CUR Strings[347]
+#define stop_bit_image                 CUR Strings[348]
+#define stop_char_set_def              CUR Strings[349]
+#define subscript_characters           CUR Strings[350]
+#define superscript_characters         CUR Strings[351]
+#define these_cause_cr                 CUR Strings[352]
+#define zero_motion                    CUR Strings[353]
+#define char_set_names                 CUR Strings[354]
+#define key_mouse                      CUR Strings[355]
+#define mouse_info                     CUR Strings[356]
+#define req_mouse_pos                  CUR Strings[357]
+#define get_mouse                      CUR Strings[358]
+#define set_a_foreground               CUR Strings[359]
+#define set_a_background               CUR Strings[360]
+#define pkey_plab                      CUR Strings[361]
+#define device_type                    CUR Strings[362]
+#define code_set_init                  CUR Strings[363]
+#define set0_des_seq                   CUR Strings[364]
+#define set1_des_seq                   CUR Strings[365]
+#define set2_des_seq                   CUR Strings[366]
+#define set3_des_seq                   CUR Strings[367]
+#define set_lr_margin                  CUR Strings[368]
+#define set_tb_margin                  CUR Strings[369]
+#define bit_image_repeat               CUR Strings[370]
+#define bit_image_newline              CUR Strings[371]
+#define bit_image_carriage_return      CUR Strings[372]
+#define color_names                    CUR Strings[373]
+#define define_bit_image_region        CUR Strings[374]
+#define end_bit_image_region           CUR Strings[375]
+#define set_color_band                 CUR Strings[376]
+#define set_page_length                CUR Strings[377]
+#define display_pc_char                CUR Strings[378]
+#define enter_pc_charset_mode          CUR Strings[379]
+#define exit_pc_charset_mode           CUR Strings[380]
+#define enter_scancode_mode            CUR Strings[381]
+#define exit_scancode_mode             CUR Strings[382]
+#define pc_term_options                CUR Strings[383]
+#define scancode_escape                CUR Strings[384]
+#define alt_scancode_esc               CUR Strings[385]
+#define enter_horizontal_hl_mode       CUR Strings[386]
+#define enter_left_hl_mode             CUR Strings[387]
+#define enter_low_hl_mode              CUR Strings[388]
+#define enter_right_hl_mode            CUR Strings[389]
+#define enter_top_hl_mode              CUR Strings[390]
+#define enter_vertical_hl_mode         CUR Strings[391]
+#define set_a_attributes               CUR Strings[392]
+#define set_pglen_inch                 CUR Strings[393]
+
+#define BOOLWRITE 37
+#define NUMWRITE  33
+#define STRWRITE  394
+
+/* older synonyms for some capabilities */
+#define beehive_glitch	no_esc_ctlc
+#define teleray_glitch	dest_tabs_magic_smso
+
+/* HPUX-11 uses this name rather than the standard one */
+#ifndef micro_char_size
+#define micro_char_size micro_col_size
+#endif
+
+#ifdef __INTERNAL_CAPS_VISIBLE
+#define termcap_init2                  CUR Strings[394]
+#define termcap_reset                  CUR Strings[395]
+#define magic_cookie_glitch_ul         CUR Numbers[33]
+#define backspaces_with_bs             CUR Booleans[37]
+#define crt_no_scrolling               CUR Booleans[38]
+#define no_correctly_working_cr        CUR Booleans[39]
+#define carriage_return_delay          CUR Numbers[34]
+#define new_line_delay                 CUR Numbers[35]
+#define linefeed_if_not_lf             CUR Strings[396]
+#define backspace_if_not_bs            CUR Strings[397]
+#define gnu_has_meta_key               CUR Booleans[40]
+#define linefeed_is_newline            CUR Booleans[41]
+#define backspace_delay                CUR Numbers[36]
+#define horizontal_tab_delay           CUR Numbers[37]
+#define number_of_function_keys        CUR Numbers[38]
+#define other_non_function_keys        CUR Strings[398]
+#define arrow_key_map                  CUR Strings[399]
+#define has_hardware_tabs              CUR Booleans[42]
+#define return_does_clr_eol            CUR Booleans[43]
+#define acs_ulcorner                   CUR Strings[400]
+#define acs_llcorner                   CUR Strings[401]
+#define acs_urcorner                   CUR Strings[402]
+#define acs_lrcorner                   CUR Strings[403]
+#define acs_ltee                       CUR Strings[404]
+#define acs_rtee                       CUR Strings[405]
+#define acs_btee                       CUR Strings[406]
+#define acs_ttee                       CUR Strings[407]
+#define acs_hline                      CUR Strings[408]
+#define acs_vline                      CUR Strings[409]
+#define acs_plus                       CUR Strings[410]
+#define memory_lock                    CUR Strings[411]
+#define memory_unlock                  CUR Strings[412]
+#define box_chars_1                    CUR Strings[413]
+#endif /* __INTERNAL_CAPS_VISIBLE */
+
+
+/*
+ * Predefined terminfo array sizes
+ */
+#define BOOLCOUNT 44
+#define NUMCOUNT  39
+#define STRCOUNT  414
+
+/* used by code for comparing entries */
+#define acs_chars_index	 146
+
+typedef struct termtype {	/* in-core form of terminfo data */
+    char  *term_names;		/* str_table offset of term names */
+    char  *str_table;		/* pointer to string table */
+    NCURSES_SBOOL  *Booleans;	/* array of boolean values */
+    short *Numbers;		/* array of integer values */
+    char  **Strings;		/* array of string offsets */
+
+#if NCURSES_XNAMES
+    char  *ext_str_table;	/* pointer to extended string table */
+    char  **ext_Names;		/* corresponding names */
+
+    unsigned short num_Booleans;/* count total Booleans */
+    unsigned short num_Numbers;	/* count total Numbers */
+    unsigned short num_Strings;	/* count total Strings */
+
+    unsigned short ext_Booleans;/* count extensions to Booleans */
+    unsigned short ext_Numbers;	/* count extensions to Numbers */
+    unsigned short ext_Strings;	/* count extensions to Strings */
+#endif /* NCURSES_XNAMES */
+
+} TERMTYPE;
+
+/*
+ * The only reason these structures are visible is for read-only use.
+ * Programs which modify the data are not, never were, portable across
+ * curses implementations.
+ *
+ * The first field in TERMINAL is used in macros.
+ * The remaining fields are private.
+ */
+#ifdef NCURSES_INTERNALS
+
+#undef TERMINAL
+#define TERMINAL struct term
+TERMINAL;
+
+typedef struct termtype2 {	/* in-core form of terminfo data */
+    char  *term_names;		/* str_table offset of term names */
+    char  *str_table;		/* pointer to string table */
+    NCURSES_SBOOL  *Booleans;	/* array of boolean values */
+    int   *Numbers;		/* array of integer values */
+    char  **Strings;		/* array of string offsets */
+
+#if NCURSES_XNAMES
+    char  *ext_str_table;	/* pointer to extended string table */
+    char  **ext_Names;		/* corresponding names */
+
+    unsigned short num_Booleans;/* count total Booleans */
+    unsigned short num_Numbers;	/* count total Numbers */
+    unsigned short num_Strings;	/* count total Strings */
+
+    unsigned short ext_Booleans;/* count extensions to Booleans */
+    unsigned short ext_Numbers;	/* count extensions to Numbers */
+    unsigned short ext_Strings;	/* count extensions to Strings */
+#endif /* NCURSES_XNAMES */
+
+} TERMTYPE2;
+#else
+
+typedef struct term {		/* describe an actual terminal */
+    TERMTYPE	type;		/* terminal type description */
+} TERMINAL;
+
+#endif /* NCURSES_INTERNALS */
+
+
+#if 0 && !0
+extern NCURSES_EXPORT_VAR(TERMINAL *) cur_term;
+#elif 0
+NCURSES_WRAPPED_VAR(TERMINAL *, cur_term);
+#define cur_term   NCURSES_PUBLIC_VAR(cur_term())
+#else
+extern NCURSES_EXPORT_VAR(TERMINAL *) cur_term;
+#endif
+
+#if 0 || 0
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolcodes);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolfnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numcodes);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numfnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strcodes);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strfnames);
+
+#define boolnames  NCURSES_PUBLIC_VAR(boolnames())
+#define boolcodes  NCURSES_PUBLIC_VAR(boolcodes())
+#define boolfnames NCURSES_PUBLIC_VAR(boolfnames())
+#define numnames   NCURSES_PUBLIC_VAR(numnames())
+#define numcodes   NCURSES_PUBLIC_VAR(numcodes())
+#define numfnames  NCURSES_PUBLIC_VAR(numfnames())
+#define strnames   NCURSES_PUBLIC_VAR(strnames())
+#define strcodes   NCURSES_PUBLIC_VAR(strcodes())
+#define strfnames  NCURSES_PUBLIC_VAR(strfnames())
+
+#else
+
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolcodes[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolfnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numcodes[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numfnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strcodes[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strfnames[];
+
+#endif
+
+/*
+ * These entrypoints are used only by the ncurses utilities such as tic.
+ */
+#ifdef NCURSES_INTERNALS
+
+extern NCURSES_EXPORT(int) _nc_set_tty_mode (TTY *buf);
+extern NCURSES_EXPORT(int) _nc_read_entry2 (const char * const, char * const, TERMTYPE2 *const);
+extern NCURSES_EXPORT(int) _nc_read_file_entry (const char *const, TERMTYPE2 *);
+extern NCURSES_EXPORT(int) _nc_read_termtype (TERMTYPE2 *, char *, int);
+extern NCURSES_EXPORT(char *) _nc_first_name (const char *const);
+extern NCURSES_EXPORT(int) _nc_name_match (const char *const, const char *const, const char *const);
+extern NCURSES_EXPORT(char *) _nc_tiparm(int, const char *, ...);
+
+#endif /* NCURSES_INTERNALS */
+
+
+/*
+ * These entrypoints are used by tack 1.07.
+ */
+extern NCURSES_EXPORT(const TERMTYPE *) _nc_fallback (const char *);
+extern NCURSES_EXPORT(int) _nc_read_entry (const char * const, char * const, TERMTYPE *const);
+
+/*
+ * Normal entry points
+ */
+extern NCURSES_EXPORT(TERMINAL *) set_curterm (TERMINAL *);
+extern NCURSES_EXPORT(int) del_curterm (TERMINAL *);
+
+/* miscellaneous entry points */
+extern NCURSES_EXPORT(int) restartterm (NCURSES_CONST char *, int, int *);
+extern NCURSES_EXPORT(int) setupterm (const char *,int,int *);
+
+/* terminfo entry points, also declared in curses.h */
+#if !defined(__NCURSES_H)
+extern NCURSES_EXPORT(char *) tigetstr (const char *);
+extern NCURSES_EXPORT_VAR(char) ttytype[];
+extern NCURSES_EXPORT(int) putp (const char *);
+extern NCURSES_EXPORT(int) tigetflag (const char *);
+extern NCURSES_EXPORT(int) tigetnum (const char *);
+
+#if 1 /* NCURSES_TPARM_VARARGS */
+extern NCURSES_EXPORT(char *) tparm (const char *, ...);	/* special */
+#else
+extern NCURSES_EXPORT(char *) tparm (const char *, long,long,long,long,long,long,long,long,long);	/* special */
+#endif
+
+extern NCURSES_EXPORT(char *) tiparm (const char *, ...);		/* special */
+
+#endif /* __NCURSES_H */
+
+/* termcap database emulation (XPG4 uses const only for 2nd param of tgetent) */
+#if !defined(NCURSES_TERMCAP_H_incl)
+extern NCURSES_EXPORT(char *) tgetstr (const char *, char **);
+extern NCURSES_EXPORT(char *) tgoto (const char *, int, int);
+extern NCURSES_EXPORT(int) tgetent (char *, const char *);
+extern NCURSES_EXPORT(int) tgetflag (const char *);
+extern NCURSES_EXPORT(int) tgetnum (const char *);
+extern NCURSES_EXPORT(int) tputs (const char *, int, int (*)(int));
+#endif /* NCURSES_TERMCAP_H_incl */
+
+/*
+ * Include curses.h before term.h to enable these extensions.
+ */
+#if defined(NCURSES_SP_FUNCS) && (NCURSES_SP_FUNCS != 0)
+
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tigetstr) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(putp) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tigetflag) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tigetnum) (SCREEN*, const char *);
+
+#if 1 /* NCURSES_TPARM_VARARGS */
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tparm) (SCREEN*, const char *, ...);	/* special */
+#else
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tparm) (SCREEN*, const char *, long,long,long,long,long,long,long,long,long);	/* special */
+#endif
+
+/* termcap database emulation (XPG4 uses const only for 2nd param of tgetent) */
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tgetstr) (SCREEN*, const char *, char **);
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tgoto) (SCREEN*, const char *, int, int);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tgetent) (SCREEN*, char *, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tgetflag) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tgetnum) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tputs) (SCREEN*, const char *, int, NCURSES_SP_OUTC);
+
+extern NCURSES_EXPORT(TERMINAL *) NCURSES_SP_NAME(set_curterm) (SCREEN*, TERMINAL *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(del_curterm) (SCREEN*, TERMINAL *);
+
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(restartterm) (SCREEN*, NCURSES_CONST char *, int, int *);
+#endif /* NCURSES_SP_FUNCS */
+
+/*
+ * Debugging features.
+ */
+extern GCC_NORETURN NCURSES_EXPORT(void)    exit_terminfo(int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NCURSES_TERM_H_incl */

llava_next/include/tkMacOSXFont.h

@@ -0,0 +1,32 @@
+/*
+ * tkMacOSXFont.h --
+ *
+ *	Contains the Macintosh implementation of the platform-independent
+ *	font package interface.
+ *
+ * Copyright (c) 1990-1994 The Regents of the University of California.
+ * Copyright (c) 1994-1997 Sun Microsystems, Inc.
+ * Copyright 2001-2009, Apple Inc.
+ * Copyright (c) 2006-2009 Daniel A. Steffen <das@users.sourceforge.net>
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef TKMACOSXFONT_H
+#define TKMACOSXFONT_H 1
+
+#include "tkFont.h"
+
+#ifndef _TKMACINT
+#include "tkMacOSXInt.h"
+#endif
+
+/*
+ * Function prototypes
+ */
+
+MODULE_SCOPE Tcl_Obj * TkMacOSXFontDescriptionForNSFontAndNSFontAttributes(
+	NSFont *nsFont, NSDictionary *nsAttributes);
+
+#endif /*TKMACOSXFONT_H*/

llava_next/include/tkMenubutton.h

@@ -0,0 +1,216 @@
+/*
+ * tkMenubutton.h --
+ *
+ *	Declarations of types and functions used to implement the menubutton
+ *	widget.
+ *
+ * Copyright (c) 1996-1997 by Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ */
+
+#ifndef _TKMENUBUTTON
+#define _TKMENUBUTTON
+
+#ifndef _TKINT
+#include "tkInt.h"
+#endif
+
+#ifndef _TKMENU
+#include "tkMenu.h"
+#endif
+
+/*
+ * Legal values for the "orient" field of TkMenubutton records.
+ */
+
+enum direction {
+    DIRECTION_ABOVE, DIRECTION_BELOW, DIRECTION_FLUSH,
+    DIRECTION_LEFT, DIRECTION_RIGHT
+};
+
+/*
+ * Legal values for the "state" field of TkMenubutton records.
+ */
+
+enum state {
+    STATE_ACTIVE, STATE_DISABLED, STATE_NORMAL
+};
+
+/*
+ * A data structure of the following type is kept for each widget managed by
+ * this file:
+ */
+
+typedef struct {
+    Tk_Window tkwin;		/* Window that embodies the widget. NULL means
+				 * that the window has been destroyed but the
+				 * data structures haven't yet been cleaned
+				 * up. */
+    Display *display;		/* Display containing widget. Needed, among
+				 * other things, so that resources can bee
+				 * freed up even after tkwin has gone away. */
+    Tcl_Interp *interp;		/* Interpreter associated with menubutton. */
+    Tcl_Command widgetCmd;	/* Token for menubutton's widget command. */
+    Tk_OptionTable optionTable;	/* Table that defines configuration options
+				 * available for this widget. */
+    char *menuName;		/* Name of menu associated with widget.
+				 * Malloc-ed. */
+
+    /*
+     * Information about what's displayed in the menu button:
+     */
+
+    char *text;			/* Text to display in button (malloc'ed) or
+				 * NULL. */
+    int underline;		/* Index of character to underline. */
+    char *textVarName;		/* Name of variable (malloc'ed) or NULL. If
+				 * non-NULL, button displays the contents of
+				 * this variable. */
+    Pixmap bitmap;		/* Bitmap to display or None. If not None then
+				 * text and textVar and underline are
+				 * ignored. */
+    char *imageString;		/* Name of image to display (malloc'ed), or
+				 * NULL. If non-NULL, bitmap, text, and
+				 * textVarName are ignored. */
+    Tk_Image image;		/* Image to display in window, or NULL if
+				 * none. */
+
+    /*
+     * Information used when displaying widget:
+     */
+
+    enum state state;		/* State of button for display purposes:
+				 * normal, active, or disabled. */
+    Tk_3DBorder normalBorder;	/* Structure used to draw 3-D border and
+				 * background when window isn't active. NULL
+				 * means no such border exists. */
+    Tk_3DBorder activeBorder;	/* Structure used to draw 3-D border and
+				 * background when window is active. NULL
+				 * means no such border exists. */
+    int borderWidth;		/* Width of border. */
+    int relief;			/* 3-d effect: TK_RELIEF_RAISED, etc. */
+    int highlightWidth;		/* Width in pixels of highlight to draw around
+				 * widget when it has the focus. <= 0 means
+				 * don't draw a highlight. */
+    XColor *highlightBgColorPtr;/* Color for drawing traversal highlight area
+				 * when highlight is off. */
+    XColor *highlightColorPtr;	/* Color for drawing traversal highlight. */
+    int inset;			/* Total width of all borders, including
+				 * traversal highlight and 3-D border.
+				 * Indicates how much interior stuff must be
+				 * offset from outside edges to leave room for
+				 * borders. */
+    Tk_Font tkfont;		/* Information about text font, or NULL. */
+    XColor *normalFg;		/* Foreground color in normal mode. */
+    XColor *activeFg;		/* Foreground color in active mode. NULL means
+				 * use normalFg instead. */
+    XColor *disabledFg;		/* Foreground color when disabled. NULL means
+				 * use normalFg with a 50% stipple instead. */
+    GC normalTextGC;		/* GC for drawing text in normal mode. */
+    GC activeTextGC;		/* GC for drawing text in active mode (NULL
+				 * means use normalTextGC). */
+    Pixmap gray;		/* Pixmap for displaying disabled text/icon if
+				 * disabledFg is NULL. */
+    GC disabledGC;		/* Used to produce disabled effect for
+				 * text. */
+    GC stippleGC;		/* Used to produce disabled stipple effect for
+				 * images when disabled. */
+    int leftBearing;		/* Distance from text origin to leftmost drawn
+				 * pixel (positive means to right). */
+    int rightBearing;		/* Amount text sticks right from its
+				 * origin. */
+    char *widthString;		/* Value of -width option. Malloc'ed. */
+    char *heightString;		/* Value of -height option. Malloc'ed. */
+    int width, height;		/* If > 0, these specify dimensions to request
+				 * for window, in characters for text and in
+				 * pixels for bitmaps. In this case the actual
+				 * size of the text string or bitmap is
+				 * ignored in computing desired window
+				 * size. */
+    int wrapLength;		/* Line length (in pixels) at which to wrap
+				 * onto next line. <= 0 means don't wrap
+				 * except at newlines. */
+    int padX, padY;		/* Extra space around text or bitmap (pixels
+				 * on each side). */
+    Tk_Anchor anchor;		/* Where text/bitmap should be displayed
+				 * inside window region. */
+    Tk_Justify justify;		/* Justification to use for multi-line
+				 * text. */
+    int textWidth;		/* Width needed to display text as requested,
+				 * in pixels. */
+    int textHeight;		/* Height needed to display text as requested,
+				 * in pixels. */
+    Tk_TextLayout textLayout;	/* Saved text layout information. */
+    int indicatorOn;		/* Non-zero means display indicator; 0 means
+				 * don't display. */
+    int indicatorHeight;	/* Height of indicator in pixels. This same
+				 * amount of extra space is also left on each
+				 * side of the indicator. 0 if no
+				 * indicator. */
+    int indicatorWidth;		/* Width of indicator in pixels, including
+				 * indicatorHeight in padding on each side. 0
+				 * if no indicator. */
+
+    /*
+     * Miscellaneous information:
+     */
+
+    int compound;		/* Value of -compound option; specifies
+				 * whether the menubutton should show both an
+				 * image and text, and, if so, how. */
+    enum direction direction;	/* Direction for where to pop the menu. Valid
+    				 * directions are "above", "below", "left",
+    				 * "right", and "flush". "flush" means that
+    				 * the upper left corner of the menubutton is
+    				 * where the menu pops up. "above" and "below"
+    				 * will attempt to pop the menu completely
+    				 * above or below the menu respectively.
+    				 * "left" and "right" will pop the menu left
+    				 * or right, and the active item will be next
+    				 * to the button. */
+    Tk_Cursor cursor;		/* Current cursor for window, or NULL. */
+    char *takeFocus;		/* Value of -takefocus option; not used in the
+				 * C code, but used by keyboard traversal
+				 * scripts. Malloc'ed, but may be NULL. */
+    int flags;			/* Various flags; see below for
+				 * definitions. */
+} TkMenuButton;
+
+/*
+ * Flag bits for buttons:
+ *
+ * REDRAW_PENDING:		Non-zero means a DoWhenIdle handler has
+ *				already been queued to redraw this window.
+ * POSTED:			Non-zero means that the menu associated with
+ *				this button has been posted (typically because
+ *				of an active button press).
+ * GOT_FOCUS:			Non-zero means this button currently has the
+ *				input focus.
+ */
+
+#define REDRAW_PENDING		1
+#define POSTED			2
+#define GOT_FOCUS		4
+
+/*
+ * The following constants define the dimensions of the cascade indicator,
+ * which is displayed if the "-indicatoron" option is true. The units for
+ * these options are 1/10 millimeters.
+ */
+
+#define INDICATOR_WIDTH		40
+#define INDICATOR_HEIGHT	17
+
+/*
+ * Declaration of procedures used in the implementation of the button widget.
+ */
+
+MODULE_SCOPE void	TkpComputeMenuButtonGeometry(TkMenuButton *mbPtr);
+MODULE_SCOPE TkMenuButton *TkpCreateMenuButton(Tk_Window tkwin);
+MODULE_SCOPE void	TkpDisplayMenuButton(ClientData clientData);
+MODULE_SCOPE void 	TkpDestroyMenuButton(TkMenuButton *mbPtr);
+MODULE_SCOPE void	TkMenuButtonWorldChanged(ClientData instanceData);
+
+#endif /* _TKMENUBUTTON */

llava_next/include/tkUuid.h

@@ -0,0 +1,3 @@
+#define TK_VERSION_UUID \
+e987bb51b8fce99b545a408b5eb2cbcecedf6929ff1f7094e383666f02a5f556
+

llava_next/share/info/history.info

@@ -0,0 +1,1426 @@
+This is history.info, produced by makeinfo version 6.8 from
+history.texi.
+
+This document describes the GNU History library (version 8.2, 19
+September 2022), a programming tool that provides a consistent user
+interface for recalling lines of previously typed input.
+
+   Copyright (C) 1988-2022 Free Software Foundation, Inc.
+
+     Permission is granted to copy, distribute and/or modify this
+     document under the terms of the GNU Free Documentation License,
+     Version 1.3 or any later version published by the Free Software
+     Foundation; with no Invariant Sections, no Front-Cover Texts, and
+     no Back-Cover Texts.  A copy of the license is included in the
+     section entitled "GNU Free Documentation License".
+
+INFO-DIR-SECTION Libraries
+START-INFO-DIR-ENTRY
+* History: (history).       The GNU history library API.
+END-INFO-DIR-ENTRY
+
+
+File: history.info,  Node: Top,  Next: Using History Interactively,  Up: (dir)
+
+GNU History Library
+*******************
+
+This document describes the GNU History library, a programming tool that
+provides a consistent user interface for recalling lines of previously
+typed input.
+
+* Menu:
+
+* Using History Interactively::	  GNU History User's Manual.
+* Programming with GNU History::  GNU History Programmer's Manual.
+* GNU Free Documentation License::	License for copying this manual.
+* Concept Index::		  Index of concepts described in this manual.
+* Function and Variable Index::	  Index of externally visible functions
+				  and variables.
+
+
+File: history.info,  Node: Using History Interactively,  Next: Programming with GNU History,  Prev: Top,  Up: Top
+
+1 Using History Interactively
+*****************************
+
+This chapter describes how to use the GNU History Library interactively,
+from a user's standpoint.  It should be considered a user's guide.  For
+information on using the GNU History Library in your own programs, *note
+Programming with GNU History::.
+
+* Menu:
+
+* History Interaction::		What it feels like using History as a user.
+
+
+File: history.info,  Node: History Interaction,  Up: Using History Interactively
+
+1.1 History Expansion
+=====================
+
+The History library provides a history expansion feature that is similar
+to the history expansion provided by 'csh'.  This section describes the
+syntax used to manipulate the history information.
+
+   History expansions introduce words from the history list into the
+input stream, making it easy to repeat commands, insert the arguments to
+a previous command into the current input line, or fix errors in
+previous commands quickly.
+
+   History expansion takes place in two parts.  The first is to
+determine which line from the history list should be used during
+substitution.  The second is to select portions of that line for
+inclusion into the current one.  The line selected from the history is
+called the "event", and the portions of that line that are acted upon
+are called "words".  Various "modifiers" are available to manipulate the
+selected words.  The line is broken into words in the same fashion that
+Bash does, so that several words surrounded by quotes are considered one
+word.  History expansions are introduced by the appearance of the
+history expansion character, which is '!' by default.
+
+   History expansion implements shell-like quoting conventions: a
+backslash can be used to remove the special handling for the next
+character; single quotes enclose verbatim sequences of characters, and
+can be used to inhibit history expansion; and characters enclosed within
+double quotes may be subject to history expansion, since backslash can
+escape the history expansion character, but single quotes may not, since
+they are not treated specially within double quotes.
+
+* Menu:
+
+* Event Designators::	How to specify which history line to use.
+* Word Designators::	Specifying which words are of interest.
+* Modifiers::		Modifying the results of substitution.
+
+
+File: history.info,  Node: Event Designators,  Next: Word Designators,  Up: History Interaction
+
+1.1.1 Event Designators
+-----------------------
+
+An event designator is a reference to a command line entry in the
+history list.  Unless the reference is absolute, events are relative to
+the current position in the history list.
+
+'!'
+     Start a history substitution, except when followed by a space, tab,
+     the end of the line, or '='.
+
+'!N'
+     Refer to command line N.
+
+'!-N'
+     Refer to the command N lines back.
+
+'!!'
+     Refer to the previous command.  This is a synonym for '!-1'.
+
+'!STRING'
+     Refer to the most recent command preceding the current position in
+     the history list starting with STRING.
+
+'!?STRING[?]'
+     Refer to the most recent command preceding the current position in
+     the history list containing STRING.  The trailing '?' may be
+     omitted if the STRING is followed immediately by a newline.  If
+     STRING is missing, the string from the most recent search is used;
+     it is an error if there is no previous search string.
+
+'^STRING1^STRING2^'
+     Quick Substitution.  Repeat the last command, replacing STRING1
+     with STRING2.  Equivalent to '!!:s^STRING1^STRING2^'.
+
+'!#'
+     The entire command line typed so far.
+
+
+File: history.info,  Node: Word Designators,  Next: Modifiers,  Prev: Event Designators,  Up: History Interaction
+
+1.1.2 Word Designators
+----------------------
+
+Word designators are used to select desired words from the event.  A ':'
+separates the event specification from the word designator.  It may be
+omitted if the word designator begins with a '^', '$', '*', '-', or '%'.
+Words are numbered from the beginning of the line, with the first word
+being denoted by 0 (zero).  Words are inserted into the current line
+separated by single spaces.
+
+   For example,
+
+'!!'
+     designates the preceding command.  When you type this, the
+     preceding command is repeated in toto.
+
+'!!:$'
+     designates the last argument of the preceding command.  This may be
+     shortened to '!$'.
+
+'!fi:2'
+     designates the second argument of the most recent command starting
+     with the letters 'fi'.
+
+   Here are the word designators:
+
+'0 (zero)'
+     The '0'th word.  For many applications, this is the command word.
+
+'N'
+     The Nth word.
+
+'^'
+     The first argument; that is, word 1.
+
+'$'
+     The last argument.
+
+'%'
+     The first word matched by the most recent '?STRING?' search, if the
+     search string begins with a character that is part of a word.
+
+'X-Y'
+     A range of words; '-Y' abbreviates '0-Y'.
+
+'*'
+     All of the words, except the '0'th.  This is a synonym for '1-$'.
+     It is not an error to use '*' if there is just one word in the
+     event; the empty string is returned in that case.
+
+'X*'
+     Abbreviates 'X-$'
+
+'X-'
+     Abbreviates 'X-$' like 'X*', but omits the last word.  If 'x' is
+     missing, it defaults to 0.
+
+   If a word designator is supplied without an event specification, the
+previous command is used as the event.
+
+
+File: history.info,  Node: Modifiers,  Prev: Word Designators,  Up: History Interaction
+
+1.1.3 Modifiers
+---------------
+
+After the optional word designator, you can add a sequence of one or
+more of the following modifiers, each preceded by a ':'.  These modify,
+or edit, the word or words selected from the history event.
+
+'h'
+     Remove a trailing pathname component, leaving only the head.
+
+'t'
+     Remove all leading pathname components, leaving the tail.
+
+'r'
+     Remove a trailing suffix of the form '.SUFFIX', leaving the
+     basename.
+
+'e'
+     Remove all but the trailing suffix.
+
+'p'
+     Print the new command but do not execute it.
+
+'s/OLD/NEW/'
+     Substitute NEW for the first occurrence of OLD in the event line.
+     Any character may be used as the delimiter in place of '/'.  The
+     delimiter may be quoted in OLD and NEW with a single backslash.  If
+     '&' appears in NEW, it is replaced by OLD.  A single backslash will
+     quote the '&'.  If OLD is null, it is set to the last OLD
+     substituted, or, if no previous history substitutions took place,
+     the last STRING in a !?STRING'[?]' search.  If NEW is null, each
+     matching OLD is deleted.  The final delimiter is optional if it is
+     the last character on the input line.
+
+'&'
+     Repeat the previous substitution.
+
+'g'
+'a'
+     Cause changes to be applied over the entire event line.  Used in
+     conjunction with 's', as in 'gs/OLD/NEW/', or with '&'.
+
+'G'
+     Apply the following 's' or '&' modifier once to each word in the
+     event.
+
+
+File: history.info,  Node: Programming with GNU History,  Next: GNU Free Documentation License,  Prev: Using History Interactively,  Up: Top
+
+2 Programming with GNU History
+******************************
+
+This chapter describes how to interface programs that you write with the
+GNU History Library.  It should be considered a technical guide.  For
+information on the interactive use of GNU History, *note Using History
+Interactively::.
+
+* Menu:
+
+* Introduction to History::	What is the GNU History library for?
+* History Storage::		How information is stored.
+* History Functions::		Functions that you can use.
+* History Variables::		Variables that control behaviour.
+* History Programming Example::	Example of using the GNU History Library.
+
+
+File: history.info,  Node: Introduction to History,  Next: History Storage,  Up: Programming with GNU History
+
+2.1 Introduction to History
+===========================
+
+Many programs read input from the user a line at a time.  The GNU
+History library is able to keep track of those lines, associate
+arbitrary data with each line, and utilize information from previous
+lines in composing new ones.
+
+   A programmer using the History library has available functions for
+remembering lines on a history list, associating arbitrary data with a
+line, removing lines from the list, searching through the list for a
+line containing an arbitrary text string, and referencing any line in
+the list directly.  In addition, a history "expansion" function is
+available which provides for a consistent user interface across
+different programs.
+
+   The user using programs written with the History library has the
+benefit of a consistent user interface with a set of well-known commands
+for manipulating the text of previous lines and using that text in new
+commands.  The basic history manipulation commands are similar to the
+history substitution provided by 'csh'.
+
+   The programmer can also use the Readline library, which includes some
+history manipulation by default, and has the added advantage of command
+line editing.
+
+   Before declaring any functions using any functionality the History
+library provides in other code, an application writer should include the
+file '<readline/history.h>' in any file that uses the History library's
+features.  It supplies extern declarations for all of the library's
+public functions and variables, and declares all of the public data
+structures.
+
+
+File: history.info,  Node: History Storage,  Next: History Functions,  Prev: Introduction to History,  Up: Programming with GNU History
+
+2.2 History Storage
+===================
+
+The history list is an array of history entries.  A history entry is
+declared as follows:
+
+     typedef void *histdata_t;
+
+     typedef struct _hist_entry {
+       char *line;
+       char *timestamp;
+       histdata_t data;
+     } HIST_ENTRY;
+
+   The history list itself might therefore be declared as
+
+     HIST_ENTRY **the_history_list;
+
+   The state of the History library is encapsulated into a single
+structure:
+
+     /*
+      * A structure used to pass around the current state of the history.
+      */
+     typedef struct _hist_state {
+       HIST_ENTRY **entries; /* Pointer to the entries themselves. */
+       int offset;           /* The location pointer within this array. */
+       int length;           /* Number of elements within this array. */
+       int size;             /* Number of slots allocated to this array. */
+       int flags;
+     } HISTORY_STATE;
+
+   If the flags member includes 'HS_STIFLED', the history has been
+stifled.
+
+
+File: history.info,  Node: History Functions,  Next: History Variables,  Prev: History Storage,  Up: Programming with GNU History
+
+2.3 History Functions
+=====================
+
+This section describes the calling sequence for the various functions
+exported by the GNU History library.
+
+* Menu:
+
+* Initializing History and State Management::	Functions to call when you
+						want to use history in a
+						program.
+* History List Management::		Functions used to manage the list
+					of history entries.
+* Information About the History List::	Functions returning information about
+					the history list.
+* Moving Around the History List::	Functions used to change the position
+					in the history list.
+* Searching the History List::		Functions to search the history list
+					for entries containing a string.
+* Managing the History File::		Functions that read and write a file
+					containing the history list.
+* History Expansion::			Functions to perform csh-like history
+					expansion.
+
+
+File: history.info,  Node: Initializing History and State Management,  Next: History List Management,  Up: History Functions
+
+2.3.1 Initializing History and State Management
+-----------------------------------------------
+
+This section describes functions used to initialize and manage the state
+of the History library when you want to use the history functions in
+your program.
+
+ -- Function: void using_history (void)
+     Begin a session in which the history functions might be used.  This
+     initializes the interactive variables.
+
+ -- Function: HISTORY_STATE * history_get_history_state (void)
+     Return a structure describing the current state of the input
+     history.
+
+ -- Function: void history_set_history_state (HISTORY_STATE *state)
+     Set the state of the history list according to STATE.
+
+
+File: history.info,  Node: History List Management,  Next: Information About the History List,  Prev: Initializing History and State Management,  Up: History Functions
+
+2.3.2 History List Management
+-----------------------------
+
+These functions manage individual entries on the history list, or set
+parameters managing the list itself.
+
+ -- Function: void add_history (const char *string)
+     Place STRING at the end of the history list.  The associated data
+     field (if any) is set to 'NULL'.  If the maximum number of history
+     entries has been set using 'stifle_history()', and the new number
+     of history entries would exceed that maximum, the oldest history
+     entry is removed.
+
+ -- Function: void add_history_time (const char *string)
+     Change the time stamp associated with the most recent history entry
+     to STRING.
+
+ -- Function: HIST_ENTRY * remove_history (int which)
+     Remove history entry at offset WHICH from the history.  The removed
+     element is returned so you can free the line, data, and containing
+     structure.
+
+ -- Function: histdata_t free_history_entry (HIST_ENTRY *histent)
+     Free the history entry HISTENT and any history library private data
+     associated with it.  Returns the application-specific data so the
+     caller can dispose of it.
+
+ -- Function: HIST_ENTRY * replace_history_entry (int which, const char
+          *line, histdata_t data)
+     Make the history entry at offset WHICH have LINE and DATA.  This
+     returns the old entry so the caller can dispose of any
+     application-specific data.  In the case of an invalid WHICH, a
+     'NULL' pointer is returned.
+
+ -- Function: void clear_history (void)
+     Clear the history list by deleting all the entries.
+
+ -- Function: void stifle_history (int max)
+     Stifle the history list, remembering only the last MAX entries.
+     The history list will contain only MAX entries at a time.
+
+ -- Function: int unstifle_history (void)
+     Stop stifling the history.  This returns the previously-set maximum
+     number of history entries (as set by 'stifle_history()').  The
+     value is positive if the history was stifled, negative if it
+     wasn't.
+
+ -- Function: int history_is_stifled (void)
+     Returns non-zero if the history is stifled, zero if it is not.
+
+
+File: history.info,  Node: Information About the History List,  Next: Moving Around the History List,  Prev: History List Management,  Up: History Functions
+
+2.3.3 Information About the History List
+----------------------------------------
+
+These functions return information about the entire history list or
+individual list entries.
+
+ -- Function: HIST_ENTRY ** history_list (void)
+     Return a 'NULL' terminated array of 'HIST_ENTRY *' which is the
+     current input history.  Element 0 of this list is the beginning of
+     time.  If there is no history, return 'NULL'.
+
+ -- Function: int where_history (void)
+     Returns the offset of the current history element.
+
+ -- Function: HIST_ENTRY * current_history (void)
+     Return the history entry at the current position, as determined by
+     'where_history()'.  If there is no entry there, return a 'NULL'
+     pointer.
+
+ -- Function: HIST_ENTRY * history_get (int offset)
+     Return the history entry at position OFFSET.  The range of valid
+     values of OFFSET starts at 'history_base' and ends at
+     HISTORY_LENGTH - 1 (*note History Variables::).  If there is no
+     entry there, or if OFFSET is outside the valid range, return a
+     'NULL' pointer.
+
+ -- Function: time_t history_get_time (HIST_ENTRY *entry)
+     Return the time stamp associated with the history entry ENTRY.  If
+     the timestamp is missing or invalid, return 0.
+
+ -- Function: int history_total_bytes (void)
+     Return the number of bytes that the primary history entries are
+     using.  This function returns the sum of the lengths of all the
+     lines in the history.
+
+
+File: history.info,  Node: Moving Around the History List,  Next: Searching the History List,  Prev: Information About the History List,  Up: History Functions
+
+2.3.4 Moving Around the History List
+------------------------------------
+
+These functions allow the current index into the history list to be set
+or changed.
+
+ -- Function: int history_set_pos (int pos)
+     Set the current history offset to POS, an absolute index into the
+     list.  Returns 1 on success, 0 if POS is less than zero or greater
+     than the number of history entries.
+
+ -- Function: HIST_ENTRY * previous_history (void)
+     Back up the current history offset to the previous history entry,
+     and return a pointer to that entry.  If there is no previous entry,
+     return a 'NULL' pointer.
+
+ -- Function: HIST_ENTRY * next_history (void)
+     If the current history offset refers to a valid history entry,
+     increment the current history offset.  If the possibly-incremented
+     history offset refers to a valid history entry, return a pointer to
+     that entry; otherwise, return a 'BNULL' pointer.
+
+
+File: history.info,  Node: Searching the History List,  Next: Managing the History File,  Prev: Moving Around the History List,  Up: History Functions
+
+2.3.5 Searching the History List
+--------------------------------
+
+These functions allow searching of the history list for entries
+containing a specific string.  Searching may be performed both forward
+and backward from the current history position.  The search may be
+"anchored", meaning that the string must match at the beginning of the
+history entry.
+
+ -- Function: int history_search (const char *string, int direction)
+     Search the history for STRING, starting at the current history
+     offset.  If DIRECTION is less than 0, then the search is through
+     previous entries, otherwise through subsequent entries.  If STRING
+     is found, then the current history index is set to that history
+     entry, and the value returned is the offset in the line of the
+     entry where STRING was found.  Otherwise, nothing is changed, and a
+     -1 is returned.
+
+ -- Function: int history_search_prefix (const char *string, int
+          direction)
+     Search the history for STRING, starting at the current history
+     offset.  The search is anchored: matching lines must begin with
+     STRING.  If DIRECTION is less than 0, then the search is through
+     previous entries, otherwise through subsequent entries.  If STRING
+     is found, then the current history index is set to that entry, and
+     the return value is 0.  Otherwise, nothing is changed, and a -1 is
+     returned.
+
+ -- Function: int history_search_pos (const char *string, int direction,
+          int pos)
+     Search for STRING in the history list, starting at POS, an absolute
+     index into the list.  If DIRECTION is negative, the search proceeds
+     backward from POS, otherwise forward.  Returns the absolute index
+     of the history element where STRING was found, or -1 otherwise.
+
+
+File: history.info,  Node: Managing the History File,  Next: History Expansion,  Prev: Searching the History List,  Up: History Functions
+
+2.3.6 Managing the History File
+-------------------------------
+
+The History library can read the history from and write it to a file.
+This section documents the functions for managing a history file.
+
+ -- Function: int read_history (const char *filename)
+     Add the contents of FILENAME to the history list, a line at a time.
+     If FILENAME is 'NULL', then read from '~/.history'.  Returns 0 if
+     successful, or 'errno' if not.
+
+ -- Function: int read_history_range (const char *filename, int from,
+          int to)
+     Read a range of lines from FILENAME, adding them to the history
+     list.  Start reading at line FROM and end at TO.  If FROM is zero,
+     start at the beginning.  If TO is less than FROM, then read until
+     the end of the file.  If FILENAME is 'NULL', then read from
+     '~/.history'.  Returns 0 if successful, or 'errno' if not.
+
+ -- Function: int write_history (const char *filename)
+     Write the current history to FILENAME, overwriting FILENAME if
+     necessary.  If FILENAME is 'NULL', then write the history list to
+     '~/.history'.  Returns 0 on success, or 'errno' on a read or write
+     error.
+
+ -- Function: int append_history (int nelements, const char *filename)
+     Append the last NELEMENTS of the history list to FILENAME.  If
+     FILENAME is 'NULL', then append to '~/.history'.  Returns 0 on
+     success, or 'errno' on a read or write error.
+
+ -- Function: int history_truncate_file (const char *filename, int
+          nlines)
+     Truncate the history file FILENAME, leaving only the last NLINES
+     lines.  If FILENAME is 'NULL', then '~/.history' is truncated.
+     Returns 0 on success, or 'errno' on failure.
+
+
+File: history.info,  Node: History Expansion,  Prev: Managing the History File,  Up: History Functions
+
+2.3.7 History Expansion
+-----------------------
+
+These functions implement history expansion.
+
+ -- Function: int history_expand (char *string, char **output)
+     Expand STRING, placing the result into OUTPUT, a pointer to a
+     string (*note History Interaction::).  Returns:
+     '0'
+          If no expansions took place (or, if the only change in the
+          text was the removal of escape characters preceding the
+          history expansion character);
+     '1'
+          if expansions did take place;
+     '-1'
+          if there was an error in expansion;
+     '2'
+          if the returned line should be displayed, but not executed, as
+          with the ':p' modifier (*note Modifiers::).
+
+     If an error occurred in expansion, then OUTPUT contains a
+     descriptive error message.
+
+ -- Function: char * get_history_event (const char *string, int *cindex,
+          int qchar)
+     Returns the text of the history event beginning at STRING +
+     *CINDEX.  *CINDEX is modified to point to after the event
+     specifier.  At function entry, CINDEX points to the index into
+     STRING where the history event specification begins.  QCHAR is a
+     character that is allowed to end the event specification in
+     addition to the "normal" terminating characters.
+
+ -- Function: char ** history_tokenize (const char *string)
+     Return an array of tokens parsed out of STRING, much as the shell
+     might.  The tokens are split on the characters in the
+     HISTORY_WORD_DELIMITERS variable, and shell quoting conventions are
+     obeyed as described below.
+
+ -- Function: char * history_arg_extract (int first, int last, const
+          char *string)
+     Extract a string segment consisting of the FIRST through LAST
+     arguments present in STRING.  Arguments are split using
+     'history_tokenize'.
+
+
+File: history.info,  Node: History Variables,  Next: History Programming Example,  Prev: History Functions,  Up: Programming with GNU History
+
+2.4 History Variables
+=====================
+
+This section describes the externally-visible variables exported by the
+GNU History Library.
+
+ -- Variable: int history_base
+     The logical offset of the first entry in the history list.
+
+ -- Variable: int history_length
+     The number of entries currently stored in the history list.
+
+ -- Variable: int history_max_entries
+     The maximum number of history entries.  This must be changed using
+     'stifle_history()'.
+
+ -- Variable: int history_write_timestamps
+     If non-zero, timestamps are written to the history file, so they
+     can be preserved between sessions.  The default value is 0, meaning
+     that timestamps are not saved.
+
+     The current timestamp format uses the value of HISTORY_COMMENT_CHAR
+     to delimit timestamp entries in the history file.  If that variable
+     does not have a value (the default), timestamps will not be
+     written.
+
+ -- Variable: char history_expansion_char
+     The character that introduces a history event.  The default is '!'.
+     Setting this to 0 inhibits history expansion.
+
+ -- Variable: char history_subst_char
+     The character that invokes word substitution if found at the start
+     of a line.  The default is '^'.
+
+ -- Variable: char history_comment_char
+     During tokenization, if this character is seen as the first
+     character of a word, then it and all subsequent characters up to a
+     newline are ignored, suppressing history expansion for the
+     remainder of the line.  This is disabled by default.
+
+ -- Variable: char * history_word_delimiters
+     The characters that separate tokens for 'history_tokenize()'.  The
+     default value is '" \t\n()<>;&|"'.
+
+ -- Variable: char * history_search_delimiter_chars
+     The list of additional characters which can delimit a history
+     search string, in addition to space, TAB, ':' and '?' in the case
+     of a substring search.  The default is empty.
+
+ -- Variable: char * history_no_expand_chars
+     The list of characters which inhibit history expansion if found
+     immediately following HISTORY_EXPANSION_CHAR.  The default is
+     space, tab, newline, carriage return, and '='.
+
+ -- Variable: int history_quotes_inhibit_expansion
+     If non-zero, the history expansion code implements shell-like
+     quoting: single-quoted words are not scanned for the history
+     expansion character or the history comment character, and
+     double-quoted words may have history expansion performed, since
+     single quotes are not special within double quotes.  The default
+     value is 0.
+
+ -- Variable: int history_quoting_state
+     An application may set this variable to indicate that the current
+     line being expanded is subject to existing quoting.  If set to ''',
+     the history expansion function will assume that the line is
+     single-quoted and inhibit expansion until it reads an unquoted
+     closing single quote; if set to '"', history expansion will assume
+     the line is double quoted until it reads an unquoted closing double
+     quote.  If set to zero, the default, the history expansion function
+     will assume the line is not quoted and treat quote characters
+     within the line as described above.  This is only effective if
+     HISTORY_QUOTES_INHIBIT_EXPANSION is set.
+
+ -- Variable: rl_linebuf_func_t * history_inhibit_expansion_function
+     This should be set to the address of a function that takes two
+     arguments: a 'char *' (STRING) and an 'int' index into that string
+     (I).  It should return a non-zero value if the history expansion
+     starting at STRING[I] should not be performed; zero if the
+     expansion should be done.  It is intended for use by applications
+     like Bash that use the history expansion character for additional
+     purposes.  By default, this variable is set to 'NULL'.
+
+
+File: history.info,  Node: History Programming Example,  Prev: History Variables,  Up: Programming with GNU History
+
+2.5 History Programming Example
+===============================
+
+The following program demonstrates simple use of the GNU History
+Library.
+
+     #include <stdio.h>
+     #include <readline/history.h>
+
+     main (argc, argv)
+          int argc;
+          char **argv;
+     {
+       char line[1024], *t;
+       int len, done = 0;
+
+       line[0] = 0;
+
+       using_history ();
+       while (!done)
+         {
+           printf ("history$ ");
+           fflush (stdout);
+           t = fgets (line, sizeof (line) - 1, stdin);
+           if (t && *t)
+             {
+               len = strlen (t);
+               if (t[len - 1] == '\n')
+                 t[len - 1] = '\0';
+             }
+
+           if (!t)
+             strcpy (line, "quit");
+
+           if (line[0])
+             {
+               char *expansion;
+               int result;
+
+               result = history_expand (line, &expansion);
+               if (result)
+                 fprintf (stderr, "%s\n", expansion);
+
+               if (result < 0 || result == 2)
+                 {
+                   free (expansion);
+                   continue;
+                 }
+
+               add_history (expansion);
+               strncpy (line, expansion, sizeof (line) - 1);
+               free (expansion);
+             }
+
+           if (strcmp (line, "quit") == 0)
+             done = 1;
+           else if (strcmp (line, "save") == 0)
+             write_history ("history_file");
+           else if (strcmp (line, "read") == 0)
+             read_history ("history_file");
+           else if (strcmp (line, "list") == 0)
+             {
+               register HIST_ENTRY **the_list;
+               register int i;
+
+               the_list = history_list ();
+               if (the_list)
+                 for (i = 0; the_list[i]; i++)
+                   printf ("%d: %s\n", i + history_base, the_list[i]->line);
+             }
+           else if (strncmp (line, "delete", 6) == 0)
+             {
+               int which;
+               if ((sscanf (line + 6, "%d", &which)) == 1)
+                 {
+                   HIST_ENTRY *entry = remove_history (which);
+                   if (!entry)
+                     fprintf (stderr, "No such entry %d\n", which);
+                   else
+                     {
+                       free (entry->line);
+                       free (entry);
+                     }
+                 }
+               else
+                 {
+                   fprintf (stderr, "non-numeric arg given to `delete'\n");
+                 }
+             }
+         }
+     }
+
+
+File: history.info,  Node: GNU Free Documentation License,  Next: Concept Index,  Prev: Programming with GNU History,  Up: Top
+
+Appendix A GNU Free Documentation License
+*****************************************
+
+                     Version 1.3, 3 November 2008
+
+     Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
+     <http://fsf.org/>
+
+     Everyone is permitted to copy and distribute verbatim copies
+     of this license document, but changing it is not allowed.
+
+  0. PREAMBLE
+
+     The purpose of this License is to make a manual, textbook, or other
+     functional and useful document "free" in the sense of freedom: to
+     assure everyone the effective freedom to copy and redistribute it,
+     with or without modifying it, either commercially or
+     noncommercially.  Secondarily, this License preserves for the
+     author and publisher a way to get credit for their work, while not
+     being considered responsible for modifications made by others.
+
+     This License is a kind of "copyleft", which means that derivative
+     works of the document must themselves be free in the same sense.
+     It complements the GNU General Public License, which is a copyleft
+     license designed for free software.
+
+     We have designed this License in order to use it for manuals for
+     free software, because free software needs free documentation: a
+     free program should come with manuals providing the same freedoms
+     that the software does.  But this License is not limited to
+     software manuals; it can be used for any textual work, regardless
+     of subject matter or whether it is published as a printed book.  We
+     recommend this License principally for works whose purpose is
+     instruction or reference.
+
+  1. APPLICABILITY AND DEFINITIONS
+
+     This License applies to any manual or other work, in any medium,
+     that contains a notice placed by the copyright holder saying it can
+     be distributed under the terms of this License.  Such a notice
+     grants a world-wide, royalty-free license, unlimited in duration,
+     to use that work under the conditions stated herein.  The
+     "Document", below, refers to any such manual or work.  Any member
+     of the public is a licensee, and is addressed as "you".  You accept
+     the license if you copy, modify or distribute the work in a way
+     requiring permission under copyright law.
+
+     A "Modified Version" of the Document means any work containing the
+     Document or a portion of it, either copied verbatim, or with
+     modifications and/or translated into another language.
+
+     A "Secondary Section" is a named appendix or a front-matter section
+     of the Document that deals exclusively with the relationship of the
+     publishers or authors of the Document to the Document's overall
+     subject (or to related matters) and contains nothing that could
+     fall directly within that overall subject.  (Thus, if the Document
+     is in part a textbook of mathematics, a Secondary Section may not
+     explain any mathematics.)  The relationship could be a matter of
+     historical connection with the subject or with related matters, or
+     of legal, commercial, philosophical, ethical or political position
+     regarding them.
+
+     The "Invariant Sections" are certain Secondary Sections whose
+     titles are designated, as being those of Invariant Sections, in the
+     notice that says that the Document is released under this License.
+     If a section does not fit the above definition of Secondary then it
+     is not allowed to be designated as Invariant.  The Document may
+     contain zero Invariant Sections.  If the Document does not identify
+     any Invariant Sections then there are none.
+
+     The "Cover Texts" are certain short passages of text that are
+     listed, as Front-Cover Texts or Back-Cover Texts, in the notice
+     that says that the Document is released under this License.  A
+     Front-Cover Text may be at most 5 words, and a Back-Cover Text may
+     be at most 25 words.
+
+     A "Transparent" copy of the Document means a machine-readable copy,
+     represented in a format whose specification is available to the
+     general public, that is suitable for revising the document
+     straightforwardly with generic text editors or (for images composed
+     of pixels) generic paint programs or (for drawings) some widely
+     available drawing editor, and that is suitable for input to text
+     formatters or for automatic translation to a variety of formats
+     suitable for input to text formatters.  A copy made in an otherwise
+     Transparent file format whose markup, or absence of markup, has
+     been arranged to thwart or discourage subsequent modification by
+     readers is not Transparent.  An image format is not Transparent if
+     used for any substantial amount of text.  A copy that is not
+     "Transparent" is called "Opaque".
+
+     Examples of suitable formats for Transparent copies include plain
+     ASCII without markup, Texinfo input format, LaTeX input format,
+     SGML or XML using a publicly available DTD, and standard-conforming
+     simple HTML, PostScript or PDF designed for human modification.
+     Examples of transparent image formats include PNG, XCF and JPG.
+     Opaque formats include proprietary formats that can be read and
+     edited only by proprietary word processors, SGML or XML for which
+     the DTD and/or processing tools are not generally available, and
+     the machine-generated HTML, PostScript or PDF produced by some word
+     processors for output purposes only.
+
+     The "Title Page" means, for a printed book, the title page itself,
+     plus such following pages as are needed to hold, legibly, the
+     material this License requires to appear in the title page.  For
+     works in formats which do not have any title page as such, "Title
+     Page" means the text near the most prominent appearance of the
+     work's title, preceding the beginning of the body of the text.
+
+     The "publisher" means any person or entity that distributes copies
+     of the Document to the public.
+
+     A section "Entitled XYZ" means a named subunit of the Document
+     whose title either is precisely XYZ or contains XYZ in parentheses
+     following text that translates XYZ in another language.  (Here XYZ
+     stands for a specific section name mentioned below, such as
+     "Acknowledgements", "Dedications", "Endorsements", or "History".)
+     To "Preserve the Title" of such a section when you modify the
+     Document means that it remains a section "Entitled XYZ" according
+     to this definition.
+
+     The Document may include Warranty Disclaimers next to the notice
+     which states that this License applies to the Document.  These
+     Warranty Disclaimers are considered to be included by reference in
+     this License, but only as regards disclaiming warranties: any other
+     implication that these Warranty Disclaimers may have is void and
+     has no effect on the meaning of this License.
+
+  2. VERBATIM COPYING
+
+     You may copy and distribute the Document in any medium, either
+     commercially or noncommercially, provided that this License, the
+     copyright notices, and the license notice saying this License
+     applies to the Document are reproduced in all copies, and that you
+     add no other conditions whatsoever to those of this License.  You
+     may not use technical measures to obstruct or control the reading
+     or further copying of the copies you make or distribute.  However,
+     you may accept compensation in exchange for copies.  If you
+     distribute a large enough number of copies you must also follow the
+     conditions in section 3.
+
+     You may also lend copies, under the same conditions stated above,
+     and you may publicly display copies.
+
+  3. COPYING IN QUANTITY
+
+     If you publish printed copies (or copies in media that commonly
+     have printed covers) of the Document, numbering more than 100, and
+     the Document's license notice requires Cover Texts, you must
+     enclose the copies in covers that carry, clearly and legibly, all
+     these Cover Texts: Front-Cover Texts on the front cover, and
+     Back-Cover Texts on the back cover.  Both covers must also clearly
+     and legibly identify you as the publisher of these copies.  The
+     front cover must present the full title with all words of the title
+     equally prominent and visible.  You may add other material on the
+     covers in addition.  Copying with changes limited to the covers, as
+     long as they preserve the title of the Document and satisfy these
+     conditions, can be treated as verbatim copying in other respects.
+
+     If the required texts for either cover are too voluminous to fit
+     legibly, you should put the first ones listed (as many as fit
+     reasonably) on the actual cover, and continue the rest onto
+     adjacent pages.
+
+     If you publish or distribute Opaque copies of the Document
+     numbering more than 100, you must either include a machine-readable
+     Transparent copy along with each Opaque copy, or state in or with
+     each Opaque copy a computer-network location from which the general
+     network-using public has access to download using public-standard
+     network protocols a complete Transparent copy of the Document, free
+     of added material.  If you use the latter option, you must take
+     reasonably prudent steps, when you begin distribution of Opaque
+     copies in quantity, to ensure that this Transparent copy will
+     remain thus accessible at the stated location until at least one
+     year after the last time you distribute an Opaque copy (directly or
+     through your agents or retailers) of that edition to the public.
+
+     It is requested, but not required, that you contact the authors of
+     the Document well before redistributing any large number of copies,
+     to give them a chance to provide you with an updated version of the
+     Document.
+
+  4. MODIFICATIONS
+
+     You may copy and distribute a Modified Version of the Document
+     under the conditions of sections 2 and 3 above, provided that you
+     release the Modified Version under precisely this License, with the
+     Modified Version filling the role of the Document, thus licensing
+     distribution and modification of the Modified Version to whoever
+     possesses a copy of it.  In addition, you must do these things in
+     the Modified Version:
+
+       A. Use in the Title Page (and on the covers, if any) a title
+          distinct from that of the Document, and from those of previous
+          versions (which should, if there were any, be listed in the
+          History section of the Document).  You may use the same title
+          as a previous version if the original publisher of that
+          version gives permission.
+
+       B. List on the Title Page, as authors, one or more persons or
+          entities responsible for authorship of the modifications in
+          the Modified Version, together with at least five of the
+          principal authors of the Document (all of its principal
+          authors, if it has fewer than five), unless they release you
+          from this requirement.
+
+       C. State on the Title page the name of the publisher of the
+          Modified Version, as the publisher.
+
+       D. Preserve all the copyright notices of the Document.
+
+       E. Add an appropriate copyright notice for your modifications
+          adjacent to the other copyright notices.
+
+       F. Include, immediately after the copyright notices, a license
+          notice giving the public permission to use the Modified
+          Version under the terms of this License, in the form shown in
+          the Addendum below.
+
+       G. Preserve in that license notice the full lists of Invariant
+          Sections and required Cover Texts given in the Document's
+          license notice.
+
+       H. Include an unaltered copy of this License.
+
+       I. Preserve the section Entitled "History", Preserve its Title,
+          and add to it an item stating at least the title, year, new
+          authors, and publisher of the Modified Version as given on the
+          Title Page.  If there is no section Entitled "History" in the
+          Document, create one stating the title, year, authors, and
+          publisher of the Document as given on its Title Page, then add
+          an item describing the Modified Version as stated in the
+          previous sentence.
+
+       J. Preserve the network location, if any, given in the Document
+          for public access to a Transparent copy of the Document, and
+          likewise the network locations given in the Document for
+          previous versions it was based on.  These may be placed in the
+          "History" section.  You may omit a network location for a work
+          that was published at least four years before the Document
+          itself, or if the original publisher of the version it refers
+          to gives permission.
+
+       K. For any section Entitled "Acknowledgements" or "Dedications",
+          Preserve the Title of the section, and preserve in the section
+          all the substance and tone of each of the contributor
+          acknowledgements and/or dedications given therein.
+
+       L. Preserve all the Invariant Sections of the Document, unaltered
+          in their text and in their titles.  Section numbers or the
+          equivalent are not considered part of the section titles.
+
+       M. Delete any section Entitled "Endorsements".  Such a section
+          may not be included in the Modified Version.
+
+       N. Do not retitle any existing section to be Entitled
+          "Endorsements" or to conflict in title with any Invariant
+          Section.
+
+       O. Preserve any Warranty Disclaimers.
+
+     If the Modified Version includes new front-matter sections or
+     appendices that qualify as Secondary Sections and contain no
+     material copied from the Document, you may at your option designate
+     some or all of these sections as invariant.  To do this, add their
+     titles to the list of Invariant Sections in the Modified Version's
+     license notice.  These titles must be distinct from any other
+     section titles.
+
+     You may add a section Entitled "Endorsements", provided it contains
+     nothing but endorsements of your Modified Version by various
+     parties--for example, statements of peer review or that the text
+     has been approved by an organization as the authoritative
+     definition of a standard.
+
+     You may add a passage of up to five words as a Front-Cover Text,
+     and a passage of up to 25 words as a Back-Cover Text, to the end of
+     the list of Cover Texts in the Modified Version.  Only one passage
+     of Front-Cover Text and one of Back-Cover Text may be added by (or
+     through arrangements made by) any one entity.  If the Document
+     already includes a cover text for the same cover, previously added
+     by you or by arrangement made by the same entity you are acting on
+     behalf of, you may not add another; but you may replace the old
+     one, on explicit permission from the previous publisher that added
+     the old one.
+
+     The author(s) and publisher(s) of the Document do not by this
+     License give permission to use their names for publicity for or to
+     assert or imply endorsement of any Modified Version.
+
+  5. COMBINING DOCUMENTS
+
+     You may combine the Document with other documents released under
+     this License, under the terms defined in section 4 above for
+     modified versions, provided that you include in the combination all
+     of the Invariant Sections of all of the original documents,
+     unmodified, and list them all as Invariant Sections of your
+     combined work in its license notice, and that you preserve all
+     their Warranty Disclaimers.
+
+     The combined work need only contain one copy of this License, and
+     multiple identical Invariant Sections may be replaced with a single
+     copy.  If there are multiple Invariant Sections with the same name
+     but different contents, make the title of each such section unique
+     by adding at the end of it, in parentheses, the name of the
+     original author or publisher of that section if known, or else a
+     unique number.  Make the same adjustment to the section titles in
+     the list of Invariant Sections in the license notice of the
+     combined work.
+
+     In the combination, you must combine any sections Entitled
+     "History" in the various original documents, forming one section
+     Entitled "History"; likewise combine any sections Entitled
+     "Acknowledgements", and any sections Entitled "Dedications".  You
+     must delete all sections Entitled "Endorsements."
+
+  6. COLLECTIONS OF DOCUMENTS
+
+     You may make a collection consisting of the Document and other
+     documents released under this License, and replace the individual
+     copies of this License in the various documents with a single copy
+     that is included in the collection, provided that you follow the
+     rules of this License for verbatim copying of each of the documents
+     in all other respects.
+
+     You may extract a single document from such a collection, and
+     distribute it individually under this License, provided you insert
+     a copy of this License into the extracted document, and follow this
+     License in all other respects regarding verbatim copying of that
+     document.
+
+  7. AGGREGATION WITH INDEPENDENT WORKS
+
+     A compilation of the Document or its derivatives with other
+     separate and independent documents or works, in or on a volume of a
+     storage or distribution medium, is called an "aggregate" if the
+     copyright resulting from the compilation is not used to limit the
+     legal rights of the compilation's users beyond what the individual
+     works permit.  When the Document is included in an aggregate, this
+     License does not apply to the other works in the aggregate which
+     are not themselves derivative works of the Document.
+
+     If the Cover Text requirement of section 3 is applicable to these
+     copies of the Document, then if the Document is less than one half
+     of the entire aggregate, the Document's Cover Texts may be placed
+     on covers that bracket the Document within the aggregate, or the
+     electronic equivalent of covers if the Document is in electronic
+     form.  Otherwise they must appear on printed covers that bracket
+     the whole aggregate.
+
+  8. TRANSLATION
+
+     Translation is considered a kind of modification, so you may
+     distribute translations of the Document under the terms of section
+     4.  Replacing Invariant Sections with translations requires special
+     permission from their copyright holders, but you may include
+     translations of some or all Invariant Sections in addition to the
+     original versions of these Invariant Sections.  You may include a
+     translation of this License, and all the license notices in the
+     Document, and any Warranty Disclaimers, provided that you also
+     include the original English version of this License and the
+     original versions of those notices and disclaimers.  In case of a
+     disagreement between the translation and the original version of
+     this License or a notice or disclaimer, the original version will
+     prevail.
+
+     If a section in the Document is Entitled "Acknowledgements",
+     "Dedications", or "History", the requirement (section 4) to
+     Preserve its Title (section 1) will typically require changing the
+     actual title.
+
+  9. TERMINATION
+
+     You may not copy, modify, sublicense, or distribute the Document
+     except as expressly provided under this License.  Any attempt
+     otherwise to copy, modify, sublicense, or distribute it is void,
+     and will automatically terminate your rights under this License.
+
+     However, if you cease all violation of this License, then your
+     license from a particular copyright holder is reinstated (a)
+     provisionally, unless and until the copyright holder explicitly and
+     finally terminates your license, and (b) permanently, if the
+     copyright holder fails to notify you of the violation by some
+     reasonable means prior to 60 days after the cessation.
+
+     Moreover, your license from a particular copyright holder is
+     reinstated permanently if the copyright holder notifies you of the
+     violation by some reasonable means, this is the first time you have
+     received notice of violation of this License (for any work) from
+     that copyright holder, and you cure the violation prior to 30 days
+     after your receipt of the notice.
+
+     Termination of your rights under this section does not terminate
+     the licenses of parties who have received copies or rights from you
+     under this License.  If your rights have been terminated and not
+     permanently reinstated, receipt of a copy of some or all of the
+     same material does not give you any rights to use it.
+
+  10. FUTURE REVISIONS OF THIS LICENSE
+
+     The Free Software Foundation may publish new, revised versions of
+     the GNU Free Documentation License from time to time.  Such new
+     versions will be similar in spirit to the present version, but may
+     differ in detail to address new problems or concerns.  See
+     <http://www.gnu.org/copyleft/>.
+
+     Each version of the License is given a distinguishing version
+     number.  If the Document specifies that a particular numbered
+     version of this License "or any later version" applies to it, you
+     have the option of following the terms and conditions either of
+     that specified version or of any later version that has been
+     published (not as a draft) by the Free Software Foundation.  If the
+     Document does not specify a version number of this License, you may
+     choose any version ever published (not as a draft) by the Free
+     Software Foundation.  If the Document specifies that a proxy can
+     decide which future versions of this License can be used, that
+     proxy's public statement of acceptance of a version permanently
+     authorizes you to choose that version for the Document.
+
+  11. RELICENSING
+
+     "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
+     World Wide Web server that publishes copyrightable works and also
+     provides prominent facilities for anybody to edit those works.  A
+     public wiki that anybody can edit is an example of such a server.
+     A "Massive Multiauthor Collaboration" (or "MMC") contained in the
+     site means any set of copyrightable works thus published on the MMC
+     site.
+
+     "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
+     license published by Creative Commons Corporation, a not-for-profit
+     corporation with a principal place of business in San Francisco,
+     California, as well as future copyleft versions of that license
+     published by that same organization.
+
+     "Incorporate" means to publish or republish a Document, in whole or
+     in part, as part of another Document.
+
+     An MMC is "eligible for relicensing" if it is licensed under this
+     License, and if all works that were first published under this
+     License somewhere other than this MMC, and subsequently
+     incorporated in whole or in part into the MMC, (1) had no cover
+     texts or invariant sections, and (2) were thus incorporated prior
+     to November 1, 2008.
+
+     The operator of an MMC Site may republish an MMC contained in the
+     site under CC-BY-SA on the same site at any time before August 1,
+     2009, provided the MMC is eligible for relicensing.
+
+ADDENDUM: How to use this License for your documents
+====================================================
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and license
+notices just after the title page:
+
+       Copyright (C)  YEAR  YOUR NAME.
+       Permission is granted to copy, distribute and/or modify this document
+       under the terms of the GNU Free Documentation License, Version 1.3
+       or any later version published by the Free Software Foundation;
+       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
+       Texts.  A copy of the license is included in the section entitled ``GNU
+       Free Documentation License''.
+
+   If you have Invariant Sections, Front-Cover Texts and Back-Cover
+Texts, replace the "with...Texts."  line with this:
+
+         with the Invariant Sections being LIST THEIR TITLES, with
+         the Front-Cover Texts being LIST, and with the Back-Cover Texts
+         being LIST.
+
+   If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+   If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of free
+software license, such as the GNU General Public License, to permit
+their use in free software.
+
+
+File: history.info,  Node: Concept Index,  Next: Function and Variable Index,  Prev: GNU Free Documentation License,  Up: Top
+
+Appendix B Concept Index
+************************
+
+[index]
+* Menu:
+
+* anchored search:                       Searching the History List.
+                                                               (line 10)
+* event designators:                     Event Designators.    (line  6)
+* history events:                        Event Designators.    (line  8)
+* history expansion:                     History Interaction.  (line  6)
+* History Searching:                     Searching the History List.
+                                                               (line  6)
+
+
+File: history.info,  Node: Function and Variable Index,  Prev: Concept Index,  Up: Top
+
+Appendix C Function and Variable Index
+**************************************
+
+[index]
+* Menu:
+
+* add_history:                           History List Management.
+                                                               (line  9)
+* add_history_time:                      History List Management.
+                                                               (line 16)
+* append_history:                        Managing the History File.
+                                                               (line 28)
+* clear_history:                         History List Management.
+                                                               (line 37)
+* current_history:                       Information About the History List.
+                                                               (line 17)
+* free_history_entry:                    History List Management.
+                                                               (line 25)
+* get_history_event:                     History Expansion.    (line 26)
+* history_arg_extract:                   History Expansion.    (line 41)
+* history_base:                          History Variables.    (line  9)
+* history_comment_char:                  History Variables.    (line 37)
+* history_expand:                        History Expansion.    (line  8)
+* history_expansion_char:                History Variables.    (line 29)
+* history_get:                           Information About the History List.
+                                                               (line 22)
+* history_get_history_state:             Initializing History and State Management.
+                                                               (line 14)
+* history_get_time:                      Information About the History List.
+                                                               (line 29)
+* history_inhibit_expansion_function:    History Variables.    (line 77)
+* history_is_stifled:                    History List Management.
+                                                               (line 50)
+* history_length:                        History Variables.    (line 12)
+* history_list:                          Information About the History List.
+                                                               (line  9)
+* history_max_entries:                   History Variables.    (line 15)
+* history_no_expand_chars:               History Variables.    (line 52)
+* history_quotes_inhibit_expansion:      History Variables.    (line 57)
+* history_quoting_state:                 History Variables.    (line 65)
+* history_search:                        Searching the History List.
+                                                               (line 12)
+* history_search_delimiter_chars:        History Variables.    (line 47)
+* history_search_pos:                    Searching the History List.
+                                                               (line 31)
+* history_search_prefix:                 Searching the History List.
+                                                               (line 21)
+* history_set_history_state:             Initializing History and State Management.
+                                                               (line 18)
+* history_set_pos:                       Moving Around the History List.
+                                                               (line  9)
+* history_subst_char:                    History Variables.    (line 33)
+* history_tokenize:                      History Expansion.    (line 35)
+* history_total_bytes:                   Information About the History List.
+                                                               (line 33)
+* history_truncate_file:                 Managing the History File.
+                                                               (line 33)
+* history_word_delimiters:               History Variables.    (line 43)
+* history_write_timestamps:              History Variables.    (line 19)
+* next_history:                          Moving Around the History List.
+                                                               (line 19)
+* previous_history:                      Moving Around the History List.
+                                                               (line 14)
+* read_history:                          Managing the History File.
+                                                               (line  9)
+* read_history_range:                    Managing the History File.
+                                                               (line 14)
+* remove_history:                        History List Management.
+                                                               (line 20)
+* replace_history_entry:                 History List Management.
+                                                               (line 30)
+* stifle_history:                        History List Management.
+                                                               (line 40)
+* unstifle_history:                      History List Management.
+                                                               (line 44)
+* using_history:                         Initializing History and State Management.
+                                                               (line 10)
+* where_history:                         Information About the History List.
+                                                               (line 14)
+* write_history:                         Managing the History File.
+                                                               (line 22)
+
+
+
+Tag Table:
+Node: Top850
+Node: Using History Interactively1495
+Node: History Interaction2003
+Node: Event Designators3901
+Node: Word Designators5175
+Node: Modifiers6935
+Node: Programming with GNU History8477
+Node: Introduction to History9221
+Node: History Storage10899
+Node: History Functions12034
+Node: Initializing History and State Management13023
+Node: History List Management13835
+Node: Information About the History List16129
+Node: Moving Around the History List17743
+Node: Searching the History List18836
+Node: Managing the History File20761
+Node: History Expansion22581
+Node: History Variables24510
+Node: History Programming Example28490
+Node: GNU Free Documentation License31167
+Node: Concept Index56339
+Node: Function and Variable Index57044
+
+End Tag Table
+
+
+Local Variables:
+coding: utf-8
+End:

videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_algorithm.py

@@ -0,0 +1,393 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Defines CalibrationAlgorithm for calculating min and max values calculated by calibration method."""
+import abc
+import itertools
+import logging
+
+import numpy as np
+
+from tensorflow.compiler.mlir.quantization.tensorflow import quantization_options_pb2 as quant_opts_pb2
+from tensorflow.compiler.mlir.quantization.tensorflow.calibrator import calibration_statistics_pb2 as calib_stats_pb2
+
+
+_CalibrationMethod = quant_opts_pb2.CalibrationOptions.CalibrationMethod
+_REGISTRY = {}
+
+
+def _implements(calib_method: _CalibrationMethod):
+  def decorator(cls):
+    assert calib_method not in _REGISTRY
+    _REGISTRY[calib_method] = cls
+    return cls
+
+  return decorator
+
+
+class _CalibrationAlgorithmBase(abc.ABC):
+  """Abstract base class for calibration algorithm."""
+
+  def __init__(
+      self,
+      statistics: calib_stats_pb2.CalibrationStatistics,
+      calib_opts: quant_opts_pb2.CalibrationOptions,
+  ):
+    self._statistics = statistics
+    self._calib_opts = calib_opts
+
+  @abc.abstractmethod
+  def get_min_max_value(self) -> tuple[float, float]:
+    pass
+
+
+class _HistogramCalibrationAlgorithmBase(_CalibrationAlgorithmBase):
+  """Base class for histogram calibrators."""
+
+  def __init__(
+      self,
+      statistics: calib_stats_pb2.CalibrationStatistics,
+      calib_opts: quant_opts_pb2.CalibrationOptions,
+  ):
+    """Builds histogram using statistics.histogram_statistics.
+
+    lower_bound                                    hist_mid
+         v                                            v
+         |=========|=========|=========|=========|=========|
+                    bin width
+
+    Args:
+      statistics: Collected calibration statistics.
+      calib_opts: Calibration options used for calculating min and max.
+    """
+    super().__init__(statistics, calib_opts)
+    hist_stats = statistics.histogram_statistics
+    self._bin_width = hist_stats.bin_width
+    self._lower_bound = hist_stats.lower_bound
+    self._hist_freq = np.array(hist_stats.hist_freq)
+    self._num_bins = len(self._hist_freq)
+    self._num_bits = 8
+    # i-th bin has a range [bins[i], bins[i + 1]).
+    # bins[i] = lower_bound + i * bin_width
+    # bins[i + 1] = lower_bound + (i + 1) * bin_width
+    # So hist_mids[i] = (lower_bound + bin_width / 2) + bin_width * i
+    first_mid = self._lower_bound + self._bin_width / 2
+    last_mid = first_mid + (self._num_bins - 1) * self._bin_width
+    self._hist_mids = np.linspace(first_mid, last_mid, self._num_bins)
+
+  def _get_dequantized_hist_mids_after_quantize(
+      self, quant_min: float, quant_max: float
+  ) -> np.ndarray:
+    """Quantizes and dequantizes hist_mids using quant_min and quant_max.
+
+    Quantization converts the range of numbers from [quant_min, quant_max] to
+    [0, 2^num_bits - 1]. Values less than quant_min are converted to 0, and
+    values greater than quant_max are converted to 2^num_bits - 1.
+
+    The histogram represents the distribution of the data, and our goal is to
+    find the quant_min and quant_max that best describe this distribution. To do
+    this, we quantize hist_mids using quant_min and quant_max and dequantize
+    them again. Then the difference between hist_mids and dequantized hist_mids
+    equates to quantization error when using quant_min and quant_max.
+
+
+    Args:
+      quant_min: The minimum real value that can be represented by a quantized
+        value.
+      quant_max: The maximum real value that can be represented by a quantized
+        value.
+
+    Returns:
+      dequantized hist_mids after quantizing by quant_min and quant_max
+    """
+    maxbound = 2**self._num_bits - 1
+    minbound = 0
+    scale = (quant_max - quant_min) / maxbound
+    zero_point = -quant_min / scale
+
+    # Limit the range of zero_point and scale in case (quant_max - quant_min)
+    # is unusually small.
+    if abs(zero_point) > 9e9:
+      zero_point = 9e9
+    if abs(scale) < 1e-9:
+      scale = 1e-9
+
+    zero_point = round(zero_point)
+    quantized_hist_mids = np.clip(
+        np.round(self._hist_mids / scale) + zero_point, minbound, maxbound
+    )
+    dequantized_hist_mids = scale * (quantized_hist_mids - zero_point)
+    return dequantized_hist_mids
+
+  def _get_weighted_mean_squared_error(
+      self, quant_min, quant_max
+  ) -> tuple[float, float, float]:
+    """Gets mean squared error between hist_mids and dequantized hist_mids.
+
+    Quantization converts the range of numbers from [quant_min, quant_max] to
+    [0, 2^num_bits - 1]. Values less than quant_min are converted to 0, and
+    values greater than quant_max are converted to 2^num_bits - 1.
+
+    Args:
+      quant_min: The minimum real value that can be represented by a quantized
+        value.
+      quant_max: The maximum real value that can be represented by a quantized
+        value.
+
+    Returns:
+      (error, quant_min, quant_max): Tuple of weighted mean squared error.
+      error = (hist_mids - dequantized_hist_mids)**2 * hist_freq
+    """
+    dequantized_hist_mids = self._get_dequantized_hist_mids_after_quantize(
+        quant_min, quant_max
+    )
+    squared_error = (self._hist_mids - dequantized_hist_mids) ** 2
+    weighted_error = np.sum(squared_error * self._hist_freq)
+    return (weighted_error, quant_min, quant_max)
+
+  def _get_min_max_value_by_expanding_range(
+      self, start_idx: int
+  ) -> tuple[float, float]:
+    """Starting from start_idx, expand left and right alternately to find the min value of mse loss.
+
+    Args:
+      start_idx: Index to start quantization.
+
+    Returns:
+      (min_value, max_value): Min and max calculated.
+    """
+    # Tuple of (mse_error, quant_min, quant_max).
+    mse_min = (float('inf'), float('inf'), float('inf'))
+    left, right = start_idx, start_idx
+
+    # If this value is true, it moves left, otherwise it moves right.
+    move_left = True
+    while not (left == 0 and right == self._num_bins - 1):
+      # Decrease left if right can't be moved or move_left is true.
+      if (move_left and left > 0) or (right == self._num_bins - 1):
+        left = max(left - 1, 0)
+      # Else increase right.
+      else:
+        right = min(right + 1, self._num_bins - 1)
+      # Toogle the move_left.
+      move_left = not move_left
+      quant_min, quant_max = self._hist_mids[left], self._hist_mids[right]
+      mse_tuple = self._get_weighted_mean_squared_error(quant_min, quant_max)
+      mse_min = min(mse_tuple, mse_min)
+    # Extract (quant_min, quant_max) from (mse_error, quant_min, quant_max).
+    min_value, max_value = mse_min[1], mse_min[2]
+    return min_value, max_value
+
+
+@_implements(_CalibrationMethod.CALIBRATION_METHOD_MIN_MAX)
+class _MinMax(_CalibrationAlgorithmBase):
+  """MinMaxCalibrationAlgorithm for calculating min and max values of calibration result.
+
+  MinMax calibration calculates the global min and global max values.
+
+  global min = min of given sample inputs
+  global max = max of given sample inputs
+  """
+
+  def get_min_max_value(self) -> tuple[float, float]:
+    """Calculates the global min and max values.
+
+    Returns:
+      (min_value, max_value): Min and max calculated using MinMax
+    """
+    return (
+        self._statistics.min_max_statistics.global_min,
+        self._statistics.min_max_statistics.global_max,
+    )
+
+
+@_implements(_CalibrationMethod.CALIBRATION_METHOD_AVERAGE_MIN_MAX)
+class _AverageMinMax(_CalibrationAlgorithmBase):
+  """AverageMinMaxCalibrationAlgorithm for calculating min and max values of calibration result.
+
+  AverageMinMax calibration calculates the average of min and max values.
+  average of min = sum of min values / number of samples
+  average of max = sum of max values / number of samples
+  """
+
+  def get_min_max_value(self) -> tuple[float, float]:
+    """Calculates the average of min and max values.
+
+    Returns:
+      (min_value, max_value): Min and max calculated using AverageMinMax
+
+    Raises:
+      ValueError: num_samples is 0.
+    """
+    average_min_max_statistics = self._statistics.average_min_max_statistics
+    # num_samples is guaranteed to be larger than 0 because
+    # get_statistics_from_calibrator throws an exception if num_samples == 0.
+    num_samples = average_min_max_statistics.num_samples
+    if num_samples == 0:
+      raise ValueError(
+          'num_samples must not be 0 when calibration method is'
+          f' AverageMinMax: {self._calib_opts}'
+      )
+    min_value, max_value = (
+        average_min_max_statistics.min_sum / num_samples,
+        average_min_max_statistics.max_sum / num_samples,
+    )
+
+    return min_value, max_value
+
+
+@_implements(_CalibrationMethod.CALIBRATION_METHOD_HISTOGRAM_PERCENTILE)
+class _HistogramPercentile(_HistogramCalibrationAlgorithmBase):
+  """HistogramPercentile for calculating min and max values of calibration result."""
+
+  def get_min_max_value(self) -> tuple[float, float]:
+    """Calculates min and max from statistics using calibration options.
+
+    A "percentile" is a statistical concept that represents the value below
+    which a given percentage of data falls in a dataset. It involves sorting the
+    data from smallest to largest and then finding the value at a specified
+    percentage position. For example, the 0.01 percentile represents the value
+    in a given data set that corresponds to the lowest 0.01% of the data.
+
+    HistogramPercentile calibration uses min_percentile and max_percentile to
+    find min and max.
+
+    min_percentile and max_percentile must be in range [0, 100].
+    min_percentile is 0.001 by default.
+    max_percentile is 99.999 by default.
+
+    Returns:
+      (min_value, max_value): Min and max calculated using HistogramPercentile
+    """
+    total_freq = sum(self._hist_freq)
+    # hist_freq_cumsum is dividing cumulative sum of hist_freq by total_freq
+    # hist_freq_cumsum's value is in range [0, 1] by its definition
+    hist_freq_cumsum = np.cumsum(self._hist_freq) / total_freq
+
+    # min_percentile and max_percentile are converted from [0, 100] to [0, 1].
+    min_quantile, max_quantile = (
+        self._calib_opts.calibration_parameters.min_percentile / 100.0,
+        self._calib_opts.calibration_parameters.max_percentile / 100.0,
+    )
+
+    # Get index of min/max quantile.
+    min_quantile_idx, max_quantile_idx = (
+        np.searchsorted(hist_freq_cumsum, min_quantile, side='right'),
+        np.searchsorted(hist_freq_cumsum, max_quantile, side='left'),
+    )
+
+    # Get value of min/max quantile index.
+    min_value, max_value = (
+        self._hist_mids[min_quantile_idx],
+        self._hist_mids[max_quantile_idx],
+    )
+
+    return min_value, max_value
+
+
+@_implements(_CalibrationMethod.CALIBRATION_METHOD_HISTOGRAM_MSE_BRUTEFORCE)
+class _HistogramMseBruteforce(_HistogramCalibrationAlgorithmBase):
+  """HistogramMseBruteforce for calculating min and max values of calibration result."""
+
+  def get_min_max_value(self) -> tuple[float, float]:
+    """Finds the optimal quant_min and quant_max by testing all possible cases.
+
+    It guarantees optimal quant_min and quant_max for the representative
+    dataset, but not for the test dataset.
+
+    Returns:
+      (min_value, max_value): Min and max calculated using
+      HistogramMseBruteforce.
+    """
+    if self._num_bins > 512:
+      logging.warning(
+          'num_bins=%d is too large. The HISTOGRAM_MSE_BRUTEFORCE method tests'
+          ' all histogram mid value pairs, so it may take a long time.',
+          self._num_bins,
+      )
+    # Tuple of (mse_error, quant_min, quant_max).
+    mse_min = (float('inf'), float('inf'), float('inf'))
+
+    # Calculate the error for all hist_mid pairs.
+    for left, right in itertools.combinations(range(self._num_bins), 2):
+      quant_min, quant_max = self._hist_mids[left], self._hist_mids[right]
+      mse_tuple = self._get_weighted_mean_squared_error(quant_min, quant_max)
+      mse_min = min(mse_tuple, mse_min)
+    min_value, max_value = mse_min[1], mse_min[2]
+
+    return min_value, max_value
+
+
+@_implements(_CalibrationMethod.CALIBRATION_METHOD_HISTOGRAM_MSE_MAX_FREQUENCY)
+class _HistogramMseMaxFrequency(_HistogramCalibrationAlgorithmBase):
+  """HistogramMseMaxFrequency for calculating min and max values of calibration result."""
+
+  def get_min_max_value(self) -> tuple[float, float]:
+    """Finds min and max starting from the index of the max frequency.
+
+     The HistogramMseMaxFrequency method starts from the bin with the highest
+     frequency and expands the range to both sides. This performs well when data
+     is well spread on both sides of the max frequency.
+
+    Returns:
+      (min_value, max_value): Min and max calculated using method to expand the
+      range based on max frequency.
+    """
+    # Find the index of max frequency.
+    freq_max_idx = np.argmax(self._hist_freq)
+    return self._get_min_max_value_by_expanding_range(freq_max_idx)
+
+
+@_implements(_CalibrationMethod.CALIBRATION_METHOD_HISTOGRAM_MSE_SYMMETRIC)
+class _HistogramMseSymmetric(_HistogramCalibrationAlgorithmBase):
+  """HistogramMseSymmetric for calculating min and max values of calibration result."""
+
+  def get_min_max_value(self) -> tuple[float, float]:
+    """Finds min and max starting from the center index.
+
+    The HistogramMseSymmetric method starts from the center bin and expands the
+    range to both sides. This works better when the data is well-centered.
+
+    Returns:
+      (min_value, max_value): Min and max calculated using the method starting
+      from center and expanding.
+    """
+
+    # This function is currently only called in this method, but will be used in
+    # other methods in the future.
+    return self._get_min_max_value_by_expanding_range(self._num_bins // 2)
+
+
+def get_min_max_value(
+    statistics: calib_stats_pb2.CalibrationStatistics,
+    calib_opts: quant_opts_pb2.CalibrationOptions,
+) -> tuple[float, float]:
+  """Calculates min and max from statistics using calibration options.
+
+  Args:
+    statistics: Collected calibration statistics.
+    calib_opts: Calibration options used for calculating min and max.
+
+  Returns:
+    (min_value, max_value): Min and max calculated using calib_opts.
+
+  Raises:
+    ValueError: Unsupported calibration method is given.
+  """
+  calib_method = calib_opts.calibration_method
+  if calib_method not in _REGISTRY:
+    raise ValueError(f'Unsupported calibration method: {calib_method}')
+
+  calibration_algorithm = _REGISTRY[calib_method](statistics, calib_opts)
+  return calibration_algorithm.get_min_max_value()

videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_statistics_pb2.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_statistics.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\nXtensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_statistics.proto\x12\x15tensorflow.calibrator\"\x9c\x04\n\x15\x43\x61librationStatistics\x12Y\n\x12min_max_statistics\x18\x01 \x01(\x0b\x32=.tensorflow.calibrator.CalibrationStatistics.MinMaxStatistics\x12h\n\x1a\x61verage_min_max_statistics\x18\x02 \x01(\x0b\x32\x44.tensorflow.calibrator.CalibrationStatistics.AverageMinMaxStatistics\x12^\n\x14histogram_statistics\x18\x03 \x01(\x0b\x32@.tensorflow.calibrator.CalibrationStatistics.HistogramStatistics\x1a:\n\x10MinMaxStatistics\x12\x12\n\nglobal_min\x18\x01 \x01(\x02\x12\x12\n\nglobal_max\x18\x02 \x01(\x02\x1aP\n\x17\x41verageMinMaxStatistics\x12\x0f\n\x07min_sum\x18\x01 \x01(\x02\x12\x0f\n\x07max_sum\x18\x02 \x01(\x02\x12\x13\n\x0bnum_samples\x18\x03 \x01(\x05\x1aP\n\x13HistogramStatistics\x12\x11\n\tbin_width\x18\x01 \x01(\x02\x12\x13\n\x0blower_bound\x18\x02 \x01(\x02\x12\x11\n\thist_freq\x18\x03 \x03(\x03\x42\x03\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.compiler.mlir.quantization.tensorflow.calibrator.calibration_statistics_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _CALIBRATIONSTATISTICS._serialized_start=116
+  _CALIBRATIONSTATISTICS._serialized_end=656
+  _CALIBRATIONSTATISTICS_MINMAXSTATISTICS._serialized_start=434
+  _CALIBRATIONSTATISTICS_MINMAXSTATISTICS._serialized_end=492
+  _CALIBRATIONSTATISTICS_AVERAGEMINMAXSTATISTICS._serialized_start=494
+  _CALIBRATIONSTATISTICS_AVERAGEMINMAXSTATISTICS._serialized_end=574
+  _CALIBRATIONSTATISTICS_HISTOGRAMSTATISTICS._serialized_start=576
+  _CALIBRATIONSTATISTICS_HISTOGRAMSTATISTICS._serialized_end=656
+# @@protoc_insertion_point(module_scope)

videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/pywrap_calibration.pyi

@@ -0,0 +1,32 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from tensorflow.compiler.mlir.quantization.tensorflow.calibrator import calibration_statistics_pb2
+
+# LINT.IfChange(clear_calibrator)
+def clear_calibrator() -> None: ...
+
+# LINT.ThenChange()
+
+# LINT.IfChange(clear_data_from_calibrator)
+def clear_data_from_calibrator(id: bytes) -> None: ...
+
+# LINT.ThenChange()
+
+# LINT.IfChange(get_statistics_from_calibrator)
+def get_statistics_from_calibrator(
+    id: bytes,
+) -> calibration_statistics_pb2.CalibrationStatistics: ...
+
+# LINT.ThenChange()

videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/exported_model_pb2.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/compiler/mlir/quantization/tensorflow/exported_model.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from tensorflow.core.framework import graph_pb2 as tensorflow_dot_core_dot_framework_dot_graph__pb2
+from tensorflow.core.protobuf import meta_graph_pb2 as tensorflow_dot_core_dot_protobuf_dot_meta__graph__pb2
+from tensorflow.core.protobuf import saver_pb2 as tensorflow_dot_core_dot_protobuf_dot_saver__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\nEtensorflow/compiler/mlir/quantization/tensorflow/exported_model.proto\x12\x17tensorflow.quantization\x1a%tensorflow/core/framework/graph.proto\x1a)tensorflow/core/protobuf/meta_graph.proto\x1a$tensorflow/core/protobuf/saver.proto\"\xbe\x03\n\rExportedModel\x12\'\n\tgraph_def\x18\x01 \x01(\x0b\x32\x14.tensorflow.GraphDef\x12\x16\n\x0einit_node_name\x18\x02 \x01(\t\x12\x16\n\x0e\x63heckpoint_dir\x18\x05 \x01(\t\x12U\n\x10\x66unction_aliases\x18\x06 \x03(\x0b\x32;.tensorflow.quantization.ExportedModel.FunctionAliasesEntry\x12\x31\n\x0f\x61sset_file_defs\x18\x08 \x03(\x0b\x32\x18.tensorflow.AssetFileDef\x12\'\n\tsaver_def\x18\n \x01(\x0b\x32\x14.tensorflow.SaverDef\x1a\x36\n\x14\x46unctionAliasesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01J\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05J\x04\x08\x07\x10\x08J\x04\x08\t\x10\nR\x15variable_shared_namesR\x11restore_node_nameR\x0esave_node_nameR\x17\x66ile_prefix_tensor_nameB\x03\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.compiler.mlir.quantization.tensorflow.exported_model_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _EXPORTEDMODEL_FUNCTIONALIASESENTRY._options = None
+  _EXPORTEDMODEL_FUNCTIONALIASESENTRY._serialized_options = b'8\001'
+  _EXPORTEDMODEL._serialized_start=219
+  _EXPORTEDMODEL._serialized_end=665
+  _EXPORTEDMODEL_FUNCTIONALIASESENTRY._serialized_start=504
+  _EXPORTEDMODEL_FUNCTIONALIASESENTRY._serialized_end=558
+# @@protoc_insertion_point(module_scope)

videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/quantization_options_pb2.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from tensorflow.core.framework import tensor_pb2 as tensorflow_dot_core_dot_framework_dot_tensor__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\nKtensorflow/compiler/mlir/quantization/tensorflow/quantization_options.proto\x12\x17tensorflow.quantization\x1a&tensorflow/core/framework/tensor.proto\"\xed\x02\n\x12QuantizationMethod\x12O\n\rpreset_method\x18\x04 \x01(\x0e\x32\x38.tensorflow.quantization.QuantizationMethod.PresetMethod\x12X\n\x1cquantization_component_specs\x18\x03 \x03(\x0b\x32\x32.tensorflow.quantization.QuantizationComponentSpec\"\xa5\x01\n\x0cPresetMethod\x12\x16\n\x12METHOD_UNSPECIFIED\x10\x00\x12\x16\n\x12METHOD_NO_QUANTIZE\x10\x01\x12\x1c\n\x18METHOD_STATIC_RANGE_INT8\x10\x02\x12\x1d\n\x19METHOD_DYNAMIC_RANGE_INT8\x10\x03\x12(\n$METHOD_STATIC_RANGE_WEIGHT_ONLY_INT8\x10\x04J\x04\x08\x01\x10\x03\"\xbe\x03\n\x19QuantizationComponentSpec\x12h\n\x16quantization_component\x18\x01 \x01(\x0e\x32H.tensorflow.quantization.QuantizationComponentSpec.QuantizationComponent\x12R\n\x0btensor_type\x18\x02 \x01(\x0e\x32=.tensorflow.quantization.QuantizationComponentSpec.TensorType\"v\n\x15QuantizationComponent\x12\x19\n\x15\x43OMPONENT_UNSPECIFIED\x10\x00\x12\x18\n\x14\x43OMPONENT_ACTIVATION\x10\x01\x12\x14\n\x10\x43OMPONENT_WEIGHT\x10\x02\x12\x12\n\x0e\x43OMPONENT_BIAS\x10\x03\"k\n\nTensorType\x12\x1a\n\x16TENSORTYPE_UNSPECIFIED\x10\x00\x12\x14\n\x10TENSORTYPE_INT_4\x10\x01\x12\x14\n\x10TENSORTYPE_INT_8\x10\x02\x12\x15\n\x11TENSORTYPE_INT_32\x10\x03\"\x87\x02\n\x18UnitWiseQuantizationSpec\x12P\n\x04unit\x18\x05 \x03(\x0b\x32\x42.tensorflow.quantization.UnitWiseQuantizationSpec.QuantizationUnit\x12H\n\x13quantization_method\x18\x06 \x01(\x0b\x32+.tensorflow.quantization.QuantizationMethod\x1aI\n\x10QuantizationUnit\x12\x0f\n\x07op_type\x18\x01 \x01(\t\x12\x11\n\tnode_name\x18\x02 \x01(\t\x12\x11\n\tfunc_name\x18\x03 \x01(\tJ\x04\x08\x01\x10\x05\"\xf9\x04\n\x12\x43\x61librationOptions\x12Y\n\x12\x63\x61libration_method\x18\x01 \x01(\x0e\x32=.tensorflow.quantization.CalibrationOptions.CalibrationMethod\x12\x61\n\x16\x63\x61libration_parameters\x18\x02 \x01(\x0b\x32\x41.tensorflow.quantization.CalibrationOptions.CalibrationParameters\x1a\x61\n\x15\x43\x61librationParameters\x12\x18\n\x10initial_num_bins\x18\x01 \x01(\x05\x12\x16\n\x0emin_percentile\x18\x02 \x01(\x02\x12\x16\n\x0emax_percentile\x18\x03 \x01(\x02\"\xc1\x02\n\x11\x43\x61librationMethod\x12\"\n\x1e\x43\x41LIBRATION_METHOD_UNSPECIFIED\x10\x00\x12\x1e\n\x1a\x43\x41LIBRATION_METHOD_MIN_MAX\x10\x01\x12&\n\"CALIBRATION_METHOD_AVERAGE_MIN_MAX\x10\x02\x12+\n\'CALIBRATION_METHOD_HISTOGRAM_PERCENTILE\x10\x03\x12/\n+CALIBRATION_METHOD_HISTOGRAM_MSE_BRUTEFORCE\x10\x04\x12\x32\n.CALIBRATION_METHOD_HISTOGRAM_MSE_MAX_FREQUENCY\x10\x05\x12.\n*CALIBRATION_METHOD_HISTOGRAM_MSE_SYMMETRIC\x10\x06\"\xd4\x01\n\x18RepresentativeDataSample\x12\x65\n\x13tensor_proto_inputs\x18\x02 \x03(\x0b\x32H.tensorflow.quantization.RepresentativeDataSample.TensorProtoInputsEntry\x1aQ\n\x16TensorProtoInputsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12&\n\x05value\x18\x02 \x01(\x0b\x32\x17.tensorflow.TensorProto:\x02\x38\x01\"I\n\x19RepresentativeDatasetFile\x12\x1c\n\x12tfrecord_file_path\x18\x01 \x01(\tH\x00\x42\x0e\n\x0c\x64\x61taset_file\"\xad\x02\n\x0f\x44\x65\x62uggerOptions\x12L\n\rdebugger_type\x18\x01 \x01(\x0e\x32\x35.tensorflow.quantization.DebuggerOptions.DebuggerType\x12#\n\x1bunquantized_dump_model_path\x18\x02 \x01(\t\x12\x14\n\x0clog_dir_path\x18\x03 \x01(\t\"\x90\x01\n\x0c\x44\x65\x62uggerType\x12\x1d\n\x19\x44\x45\x42UGGER_TYPE_UNSPECIFIED\x10\x00\x12\x1d\n\x19\x44\x45\x42UGGER_TYPE_WHOLE_MODEL\x10\x01\x12\x1f\n\x1b\x44\x45\x42UGGER_TYPE_INT_PER_LAYER\x10\x02\x12!\n\x1d\x44\x45\x42UGGER_TYPE_FLOAT_PER_LAYER\x10\x03\"\xa5\x07\n\x13QuantizationOptions\x12H\n\x13quantization_method\x18\x01 \x01(\x0b\x32+.tensorflow.quantization.QuantizationMethod\x12.\n\x06op_set\x18\x02 \x01(\x0e\x32\x1e.tensorflow.quantization.OpSet\x12W\n\x1cunit_wise_quantization_specs\x18\x11 \x03(\x0b\x32\x31.tensorflow.quantization.UnitWiseQuantizationSpec\x12\x0c\n\x04tags\x18\x05 \x03(\t\x12\x16\n\x0esignature_keys\x18\x06 \x03(\t\x12i\n\x17representative_datasets\x18\x07 \x03(\x0b\x32H.tensorflow.quantization.QuantizationOptions.RepresentativeDatasetsEntry\x12$\n\x1cmin_num_elements_for_weights\x18\x08 \x01(\x03\x12!\n\x14\x66reeze_all_variables\x18\t \x01(\x08H\x00\x88\x01\x01\x12\'\n\x1f\x65nable_per_channel_quantization\x18\n \x01(\x08\x12 \n\x18\x65nable_two_input_tensors\x18\x0b \x01(\x08\x12-\n%experimental_enable_tpu_model_support\x18\x0c \x01(\x08\x12!\n\x19\x65nable_legacy_weight_only\x18\r \x01(\x08\x12$\n\x1c\x66orce_graph_mode_calibration\x18\x0e \x01(\x08\x12H\n\x13\x63\x61libration_options\x18\x0f \x01(\x0b\x32+.tensorflow.quantization.CalibrationOptions\x12\x42\n\x10\x64\x65\x62ugger_options\x18\x10 \x01(\x0b\x32(.tensorflow.quantization.DebuggerOptions\x1aq\n\x1bRepresentativeDatasetsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x41\n\x05value\x18\x02 \x01(\x0b\x32\x32.tensorflow.quantization.RepresentativeDatasetFile:\x02\x38\x01\x42\x17\n\x15_freeze_all_variablesJ\x04\x08\x03\x10\x04*V\n\x05OpSet\x12\x16\n\x12OP_SET_UNSPECIFIED\x10\x00\x12\x06\n\x02TF\x10\x01\x12\x07\n\x03XLA\x10\x02\x12\x15\n\x11UNIFORM_QUANTIZED\x10\x03\x12\r\n\tSTABLEHLO\x10\x04\x42\x03\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.compiler.mlir.quantization.tensorflow.quantization_options_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _REPRESENTATIVEDATASAMPLE_TENSORPROTOINPUTSENTRY._options = None
+  _REPRESENTATIVEDATASAMPLE_TENSORPROTOINPUTSENTRY._serialized_options = b'8\001'
+  _QUANTIZATIONOPTIONS_REPRESENTATIVEDATASETSENTRY._options = None
+  _QUANTIZATIONOPTIONS_REPRESENTATIVEDATASETSENTRY._serialized_options = b'8\001'
+  _OPSET._serialized_start=3393
+  _OPSET._serialized_end=3479
+  _QUANTIZATIONMETHOD._serialized_start=145
+  _QUANTIZATIONMETHOD._serialized_end=510
+  _QUANTIZATIONMETHOD_PRESETMETHOD._serialized_start=339
+  _QUANTIZATIONMETHOD_PRESETMETHOD._serialized_end=504
+  _QUANTIZATIONCOMPONENTSPEC._serialized_start=513
+  _QUANTIZATIONCOMPONENTSPEC._serialized_end=959
+  _QUANTIZATIONCOMPONENTSPEC_QUANTIZATIONCOMPONENT._serialized_start=732
+  _QUANTIZATIONCOMPONENTSPEC_QUANTIZATIONCOMPONENT._serialized_end=850
+  _QUANTIZATIONCOMPONENTSPEC_TENSORTYPE._serialized_start=852
+  _QUANTIZATIONCOMPONENTSPEC_TENSORTYPE._serialized_end=959
+  _UNITWISEQUANTIZATIONSPEC._serialized_start=962
+  _UNITWISEQUANTIZATIONSPEC._serialized_end=1225
+  _UNITWISEQUANTIZATIONSPEC_QUANTIZATIONUNIT._serialized_start=1146
+  _UNITWISEQUANTIZATIONSPEC_QUANTIZATIONUNIT._serialized_end=1219
+  _CALIBRATIONOPTIONS._serialized_start=1228
+  _CALIBRATIONOPTIONS._serialized_end=1861
+  _CALIBRATIONOPTIONS_CALIBRATIONPARAMETERS._serialized_start=1440
+  _CALIBRATIONOPTIONS_CALIBRATIONPARAMETERS._serialized_end=1537
+  _CALIBRATIONOPTIONS_CALIBRATIONMETHOD._serialized_start=1540
+  _CALIBRATIONOPTIONS_CALIBRATIONMETHOD._serialized_end=1861
+  _REPRESENTATIVEDATASAMPLE._serialized_start=1864
+  _REPRESENTATIVEDATASAMPLE._serialized_end=2076
+  _REPRESENTATIVEDATASAMPLE_TENSORPROTOINPUTSENTRY._serialized_start=1995
+  _REPRESENTATIVEDATASAMPLE_TENSORPROTOINPUTSENTRY._serialized_end=2076
+  _REPRESENTATIVEDATASETFILE._serialized_start=2078
+  _REPRESENTATIVEDATASETFILE._serialized_end=2151
+  _DEBUGGEROPTIONS._serialized_start=2154
+  _DEBUGGEROPTIONS._serialized_end=2455
+  _DEBUGGEROPTIONS_DEBUGGERTYPE._serialized_start=2311
+  _DEBUGGEROPTIONS_DEBUGGERTYPE._serialized_end=2455
+  _QUANTIZATIONOPTIONS._serialized_start=2458
+  _QUANTIZATIONOPTIONS._serialized_end=3391
+  _QUANTIZATIONOPTIONS_REPRESENTATIVEDATASETSENTRY._serialized_start=3247
+  _QUANTIZATIONOPTIONS_REPRESENTATIVEDATASETSENTRY._serialized_end=3360
+# @@protoc_insertion_point(module_scope)

videochat2/lib/python3.10/site-packages/tensorflow/compiler/tf2tensorrt/_pywrap_py_utils.pyi

@@ -0,0 +1,19 @@
+# Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+def get_linked_tensorrt_version() -> tuple[int,int,int]: ...
+def get_loaded_tensorrt_version() -> tuple[int,int,int]: ...
+def get_registered_op_converters() -> list[str]: ...
+def is_tensorrt_enabled() -> bool: ...

videochat2/lib/python3.10/site-packages/tensorflow/compiler/tf2xla/python/xla.py

@@ -0,0 +1,726 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Experimental library that exposes XLA operations directly in TensorFlow.
+
+It is sometimes useful to be able to build HLO programs directly from
+TensorFlow. This file provides Tensorflow operators that mirror the semantics of
+HLO operators as closely as possible.
+
+Note: Most of the operators defined in this module are used by the jax2tf
+converter (see go/jax2tf for details) and are used in SavedModel produced
+by jax2tf. Hence, we need to maintain backwards compatibility for these
+operators. Please reach out to the JAX team if you want to make changes.
+"""
+
+from tensorflow.compiler.tf2xla.ops import gen_xla_ops
+from tensorflow.compiler.xla import xla_data_pb2
+from tensorflow.core.framework import attr_value_pb2
+from tensorflow.python.framework import constant_op
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import ops
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import bitwise_ops
+from tensorflow.python.ops import gen_math_ops
+from tensorflow.python.ops import gen_random_ops
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import random_ops
+from tensorflow.python.ops import random_ops_util
+from tensorflow.python.ops import special_math_ops
+from tensorflow.python.ops.numpy_ops import np_utils
+
+# TODO(phawkins): provide wrappers for all XLA operators. Currently the missing
+# ops include:
+# infeed/outfeed (available via tf.contrib.tpu)
+# collectives, e.g., cross-replica-sum (available via tf.contrib.tpu)
+# conditional
+# gather/scatter
+# collapse
+
+# This file reuses builtin names (following XLA's names, so we can call things
+# like xla.max), so we capture the builtin versions here.
+# pylint: disable=redefined-builtin
+_max = max
+_min = min
+_slice = slice  # pylint: disable=invalid-name
+
+constant = constant_op.constant
+
+# Unary operators.
+
+# For most arithmetic operators there is a TensorFlow operator
+# that exactly corresponds to each XLA operator. Rather than defining
+# XLA-specific variants, we reuse the corresponding TensorFlow operator.
+# TODO(phawkins): It would be even better to have TensorFlow operators that 1:1
+# wrap every HLO operator, because that would allow us to be confident that the
+# semantics match.
+
+
+def _unary_op(fn):
+  """Wrapper that restricts `fn` to have the correct signature."""
+
+  def unary_op_wrapper(x, name=None):
+    return fn(x, name=name)
+
+  return unary_op_wrapper
+
+
+abs = _unary_op(math_ops.abs)
+# TODO(phawkins): implement clz.
+conj = _unary_op(math_ops.conj)
+cos = _unary_op(math_ops.cos)
+ceil = _unary_op(math_ops.ceil)
+digamma = _unary_op(math_ops.digamma)
+erf = _unary_op(math_ops.erf)
+erfc = _unary_op(math_ops.erfc)
+erfinv = _unary_op(math_ops.erfinv)
+ndtri = _unary_op(math_ops.ndtri)
+exp = _unary_op(math_ops.exp)
+expm1 = _unary_op(math_ops.expm1)
+floor = _unary_op(math_ops.floor)
+imag = _unary_op(math_ops.imag)
+is_finite = _unary_op(math_ops.is_finite)
+lgamma = _unary_op(math_ops.lgamma)
+log = _unary_op(math_ops.log)
+log1p = _unary_op(math_ops.log1p)
+logical_not = _unary_op(math_ops.logical_not)
+neg = _unary_op(math_ops.neg)
+real = _unary_op(math_ops.real)
+# TODO(phawkins): unlike xla::Round, this rounds to even instead of zero for
+# numbers halfway between two integers.
+round = _unary_op(math_ops.round)
+sin = _unary_op(math_ops.sin)
+sign = _unary_op(math_ops.sign)
+tan = _unary_op(math_ops.tan)
+tanh = _unary_op(math_ops.tanh)
+
+# Bessel
+bessel_i0e = _unary_op(special_math_ops.bessel_i0e)
+bessel_i1e = _unary_op(special_math_ops.bessel_i1e)
+
+# Binary operators
+
+# The main difference between TensorFlow and XLA binary ops is the broadcasting
+# semantics. TensorFlow uses Numpy-style broadcasting semantics, whereas XLA
+# requires an explicit specification of which dimensions to broadcast if the
+# arguments have different ranks.
+
+
+def _broadcasting_binary_op(fn):
+  """Wraps a binary Tensorflow operator and performs XLA-style broadcasting."""
+
+  def broadcasting_binary_op_wrapper(x, y, broadcast_dims=None, name=None):
+    """Inner wrapper function."""
+    broadcast_dims = broadcast_dims or []
+    broadcast_dims = ops.convert_to_tensor(broadcast_dims, dtypes.int64)
+    # Rather than relying on having static shape information in the TensorFlow
+    # graph, we use an XlaBroadcastHelper op that can compute the correct shapes
+    # at JIT compilation time.
+    x, y = gen_xla_ops.xla_broadcast_helper(x, y, broadcast_dims)
+    return fn(x, y, name=name)
+
+  return broadcasting_binary_op_wrapper
+
+
+# Map from TF signed types to TF unsigned types.
+_SIGNED_TO_UNSIGNED_TABLE = {
+    dtypes.int8: dtypes.uint8,
+    dtypes.int16: dtypes.uint16,
+    dtypes.int32: dtypes.uint32,
+    dtypes.int64: dtypes.uint64,
+}
+
+# Map from TF unsigned types to TF signed types.
+_UNSIGNED_TO_SIGNED_TABLE = {
+    dtypes.uint8: dtypes.int8,
+    dtypes.uint16: dtypes.int16,
+    dtypes.uint32: dtypes.int32,
+    dtypes.uint64: dtypes.int64,
+}
+
+
+def _shift_right_logical_helper(x, y, name=None):
+  """Performs an integer right logical shift irrespective of input type."""
+  assert y.dtype == x.dtype
+  dtype = x.dtype
+  signed = dtype in _SIGNED_TO_UNSIGNED_TABLE
+  if signed:
+    unsigned_dtype = _SIGNED_TO_UNSIGNED_TABLE[dtype]
+    x = math_ops.cast(x, unsigned_dtype)
+    y = math_ops.cast(y, unsigned_dtype)
+  output = bitwise_ops.right_shift(x, y, name=name)
+  if signed:
+    output = math_ops.cast(output, dtype)
+  return output
+
+
+def _shift_right_arithmetic_helper(x, y, name=None):
+  """Performs an integer right arithmetic shift irrespective of input type."""
+  assert y.dtype == x.dtype
+  dtype = x.dtype
+  unsigned = dtype in _UNSIGNED_TO_SIGNED_TABLE
+  if unsigned:
+    signed_dtype = _UNSIGNED_TO_SIGNED_TABLE[dtype]
+    x = math_ops.cast(x, signed_dtype)
+    y = math_ops.cast(y, signed_dtype)
+  output = bitwise_ops.right_shift(x, y, name=name)
+  if unsigned:
+    output = math_ops.cast(output, dtype)
+  return output
+
+
+add = _broadcasting_binary_op(math_ops.add)
+sub = _broadcasting_binary_op(math_ops.sub)
+mul = _broadcasting_binary_op(math_ops.mul)
+div = _broadcasting_binary_op(math_ops.div)
+rem = _broadcasting_binary_op(gen_math_ops.mod)
+max = _broadcasting_binary_op(math_ops.maximum)
+min = _broadcasting_binary_op(math_ops.minimum)
+atan2 = _broadcasting_binary_op(math_ops.atan2)
+complex = _broadcasting_binary_op(math_ops.complex)
+logical_and = _broadcasting_binary_op(math_ops.logical_and)
+logical_or = _broadcasting_binary_op(math_ops.logical_or)
+logical_xor = _broadcasting_binary_op(math_ops.logical_xor)
+eq = _broadcasting_binary_op(math_ops.equal)
+ne = _broadcasting_binary_op(math_ops.not_equal)
+ge = _broadcasting_binary_op(math_ops.greater_equal)
+gt = _broadcasting_binary_op(math_ops.greater)
+le = _broadcasting_binary_op(math_ops.less_equal)
+lt = _broadcasting_binary_op(math_ops.less)
+pow = _broadcasting_binary_op(math_ops.pow)
+shift_left = _broadcasting_binary_op(bitwise_ops.left_shift)
+shift_right_logical = _broadcasting_binary_op(_shift_right_logical_helper)
+shift_right_arithmetic = _broadcasting_binary_op(_shift_right_arithmetic_helper)
+
+igamma = _broadcasting_binary_op(math_ops.igamma)
+igamma_grad_a = _broadcasting_binary_op(gen_math_ops.igamma_grad_a)
+random_gamma_grad = _broadcasting_binary_op(gen_random_ops.random_gamma_grad)
+igammac = _broadcasting_binary_op(math_ops.igammac)
+polygamma = _broadcasting_binary_op(math_ops.polygamma)
+zeta = _broadcasting_binary_op(math_ops.zeta)
+
+
+def _binary_op(fn):
+  """Wrapper that restricts `fn` to have the correct signature."""
+
+  def binary_op_wrapper(x, y, name=None):
+    return fn(x, y, name=name)
+
+  return binary_op_wrapper
+
+
+transpose = _binary_op(array_ops.transpose)
+rev = _binary_op(array_ops.reverse)
+
+bitcast_convert_type = array_ops.bitcast
+
+
+def broadcast(x, dims, name=None):
+  x = ops.convert_to_tensor(x)
+  shape = array_ops.concat(
+      [constant_op.constant(dims), array_ops.shape(x)], axis=0
+  )
+  return array_ops.broadcast_to(x, shape, name=name)
+
+
+def clamp(a, x, b, name=None):
+  return min(max(a, x, name=name), b, name=name)
+
+
+concatenate = array_ops.concat
+
+
+def conv(
+    lhs,
+    rhs,
+    window_strides,
+    padding,
+    lhs_dilation,
+    rhs_dilation,
+    dimension_numbers,
+    feature_group_count=1,
+    precision_config=None,
+    preferred_element_type=None,
+    name=None,
+    use_v2=False,
+    batch_group_count=1,
+):
+  """Wraps the XLA ConvGeneralDilated operator.
+
+  ConvGeneralDilated is the most general form of XLA convolution and is
+  documented at
+  https://www.tensorflow.org/performance/xla/operation_semantics#conv_convolution
+
+  Args:
+    lhs: the input tensor
+    rhs: the kernel tensor
+    window_strides: the inter-window strides
+    padding: the padding to apply at the start and end of each input dimensions
+    lhs_dilation: dilation to apply between input elements
+    rhs_dilation: dilation to apply between kernel elements
+    dimension_numbers: a `ConvolutionDimensionNumbers` proto.
+    feature_group_count: number of feature groups for grouped convolution.
+    precision_config: a `xla.PrecisionConfig` proto.
+    preferred_element_type: the result `dtype`.
+    name: an optional name for the operator.
+    use_v2: an optional request to use the XlaConvV2 op even if not necessary.
+    batch_group_count: number of batch groups or grouped filters.
+
+  Returns:
+    A tensor representing the output of the convolution.
+  """
+  precision_config_proto = ""
+  if precision_config:
+    precision_config_proto = precision_config.SerializeToString()
+  needs_v2 = (
+      preferred_element_type
+      or (lhs.dtype != rhs.dtype)
+      or batch_group_count > 1
+  )
+  if preferred_element_type is None:
+    preferred_element_type = np_utils.result_type(lhs.dtype, rhs.dtype)
+  if needs_v2 or use_v2:
+    return gen_xla_ops.xla_conv_v2(
+        lhs,
+        rhs,
+        window_strides=window_strides,
+        padding=padding,
+        lhs_dilation=lhs_dilation,
+        rhs_dilation=rhs_dilation,
+        feature_group_count=feature_group_count,
+        batch_group_count=batch_group_count,
+        dimension_numbers=dimension_numbers.SerializeToString(),
+        precision_config=precision_config_proto,
+        preferred_element_type=preferred_element_type,
+        name=name,
+    )
+  return gen_xla_ops.xla_conv(
+      lhs,
+      rhs,
+      window_strides=window_strides,
+      padding=padding,
+      lhs_dilation=lhs_dilation,
+      rhs_dilation=rhs_dilation,
+      feature_group_count=feature_group_count,
+      dimension_numbers=dimension_numbers.SerializeToString(),
+      precision_config=precision_config_proto,
+      name=name,
+  )
+
+
+convert_element_type = math_ops.cast
+
+
+def dot(lhs, rhs, name=None):
+  return math_ops.tensordot(lhs, rhs, axes=1, name=name)
+
+
+DotDimensionNumbers = xla_data_pb2.DotDimensionNumbers
+PrecisionConfig = xla_data_pb2.PrecisionConfig
+
+
+def dot_general(
+    lhs,
+    rhs,
+    dimension_numbers,
+    precision_config=None,
+    preferred_element_type=None,
+    name=None,
+    use_v2=False,
+):
+  precision_config_proto = ""
+  if precision_config:
+    precision_config_proto = precision_config.SerializeToString()
+  needs_v2 = preferred_element_type or (lhs.dtype != rhs.dtype)
+  if preferred_element_type is None:
+    preferred_element_type = np_utils.result_type(lhs.dtype, rhs.dtype)
+  if needs_v2 or use_v2:
+    return gen_xla_ops.xla_dot_v2(
+        lhs,
+        rhs,
+        dimension_numbers=dimension_numbers.SerializeToString(),
+        precision_config=precision_config_proto,
+        preferred_element_type=preferred_element_type,
+        name=name,
+    )
+  return gen_xla_ops.xla_dot(
+      lhs,
+      rhs,
+      dimension_numbers=dimension_numbers.SerializeToString(),
+      precision_config=precision_config_proto,
+      name=name,
+  )
+
+
+def self_adjoint_eig(a, lower, max_iter, epsilon):
+  return gen_xla_ops.xla_self_adjoint_eig(a, lower, max_iter, epsilon)
+
+
+def svd(a, max_iter, epsilon, precision_config=None):
+  precision_config_proto = ""
+  if precision_config:
+    precision_config_proto = precision_config.SerializeToString()
+  return gen_xla_ops.xla_svd(a, max_iter, epsilon, precision_config_proto)
+
+
+dynamic_slice = gen_xla_ops.xla_dynamic_slice
+dynamic_update_slice = gen_xla_ops.xla_dynamic_update_slice
+einsum = gen_xla_ops.xla_einsum
+
+# TODO(phawkins): generalize tf.pad to support interior padding, and then remove
+# the XLA-specific pad operator.
+pad = gen_xla_ops.xla_pad
+
+
+def random_normal(mu, sigma, dims, name=None):
+  mu = ops.convert_to_tensor(mu)
+  return random_ops.random_normal(
+      dims, mean=mu, stddev=sigma, dtype=mu.dtype, name=name
+  )
+
+
+def random_uniform(minval, maxval, dims, name=None):
+  minval = ops.convert_to_tensor(minval)
+  return random_ops.random_uniform(
+      dims, minval, maxval, dtype=minval.dtype, name=name
+  )
+
+
+def rng_bit_generator(algorithm, initial_state, shape, dtype):
+  """Stateless PRNG bit generator.
+
+  Wraps the XLA RngBitGenerator operator, documented at
+    https://www.tensorflow.org/performance/xla/operation_semantics#rngbitgenerator.
+
+  Args:
+    algorithm: The PRNG algorithm to use, one of tf.random.Algorithm.{PHILOX,
+      THREEFRY, AUTO_SELECT}.
+    initial_state: Initial state for the PRNG algorithm. For THREEFRY, it should
+      be a u64[2] and for PHILOX a u64[3].
+    shape: The output shape of the generated data.
+    dtype: The type of the tensor.
+
+  Returns:
+    a tuple with a new state and generated data of the given shape.
+  """
+  alg_int = random_ops_util.convert_alg_to_int(algorithm)
+  return gen_xla_ops.xla_rng_bit_generator(
+      alg_int, initial_state, shape, dtype=dtype
+  )
+
+
+recv = gen_xla_ops.xla_recv
+reduce = gen_xla_ops.xla_reduce
+variadic_reduce = gen_xla_ops.xla_variadic_reduce_v2
+
+ops.no_gradient("XlaVariadicReduce")
+
+
+def reduce_window(
+    operand,
+    init,
+    reducer,
+    window_dimensions,
+    window_strides=None,
+    base_dilations=None,
+    window_dilations=None,
+    padding=None,
+    name=None,
+):
+  """Wraps the XLA ReduceWindow operator.
+
+  ReduceWindow is documented at
+  https://www.tensorflow.org/performance/xla/operation_semantics#reducewindow .
+
+  Args:
+    operand: the input tensor
+    init: a scalar tensor representing the initial value for the reduction
+    reducer: a reduction function that combines a pair of scalars.
+    window_dimensions: shape of the window, as a list of integers
+    window_strides: inter-window strides, as a list of integers. Optional; if
+      omitted, defaults to strides of 1.
+    padding: padding to apply to 'operand'. List of (low, high) pairs of
+      integers that specify the padding to apply before and after each
+      dimension. Optional; if omitted, defaults to no padding.
+    name: the operator name, or None.
+
+  Returns:
+    A tensor that represents the output of the reduce_window operator.
+  """
+  window_strides = window_strides or [1] * len(window_dimensions)
+  base_dilations = base_dilations or [1] * len(window_dimensions)
+  window_dilations = window_dilations or [1] * len(window_dimensions)
+  padding = padding or [(0, 0)] * len(window_dimensions)
+  return gen_xla_ops.xla_reduce_window(
+      input=operand,
+      init_value=init,
+      window_dimensions=window_dimensions,
+      window_strides=window_strides,
+      base_dilations=base_dilations,
+      window_dilations=window_dilations,
+      padding=padding,
+      computation=reducer,
+      name=name,
+  )
+
+
+replica_id = gen_xla_ops.xla_replica_id
+
+# Set a static bound for the given input value as a hint to Xla compiler,
+# returns the same value.
+# Usage:
+# def f(t, p):
+#   p = xla.set_bound(p, 3) # Tells xla the constraint that p <= 3.
+#   return t[:p]            # xla knows the bound of the slice is 3.
+set_bound = gen_xla_ops.xla_set_bound
+
+# Make a static dimension into a xla bounded dynamic dimension. The current
+# static dimension size will become the bound and the second operand becomes the
+# dynamic size of the dimension.
+#
+# This should mostly be used for testing.
+#
+# def f():
+#   array = tf.convert_to_tensor([[1, 2, 3, 4, 5]])
+#   # Tells xla the valid size of the array is 3.
+#   dim = 0
+#   p = xla_set_dynamic_dimension_size(array, dim, 3)
+#   assert(reduce_sum(p) == 6) # xla knows only the first 3 elements are valid.
+set_dynamic_dimension_size = gen_xla_ops.xla_set_dynamic_dimension_size
+
+# Inverse of xla_set_dynamic_dimension_size. Make an xla bounded dynamic
+# dimension into a static dimension. The bound of the size of dimension
+# `dim_index` becomes the static dimension size.
+remove_dynamic_dimension_size = gen_xla_ops.xla_remove_dynamic_dimension_size
+
+
+def reshape(x, new_sizes, dimensions=None, name=None):
+  if dimensions is not None:
+    x = array_ops.transpose(x, dimensions)
+  x = array_ops.reshape(x, new_sizes, name=name)
+  return x
+
+
+def select(condition, x, y, name=None):
+  return array_ops.where(condition, x, y, name)
+
+
+select_and_scatter = gen_xla_ops.xla_select_and_scatter
+send = gen_xla_ops.xla_send
+
+
+def slice(x, start_dims, limit_dims, strides):
+  spec = [
+      _slice(start, limit, stride)
+      for (start, limit, stride) in zip(start_dims, limit_dims, strides)
+  ]
+  return x[tuple(spec)]
+
+
+sharding = gen_xla_ops.xla_sharding
+
+
+@ops.RegisterGradient("XlaSharding")
+def _sharding_grad(op, grad):
+  """Gradient for XlaSharding op."""
+  sharding_attr = op.get_attr("sharding")
+  grad_sharding = gen_xla_ops.xla_sharding(
+      grad,
+      sharding=sharding_attr,
+      unspecified_dims=op.get_attr("unspecified_dims"),
+  )
+  # pylint: disable=protected-access
+  grad_sharding.op._set_attr(
+      "_XlaSharding", attr_value_pb2.AttrValue(s=sharding_attr)
+  )
+  return [grad_sharding]
+
+
+spmd_full_to_shard_shape = gen_xla_ops.xla_spmd_full_to_shard_shape
+spmd_shard_to_full_shape = gen_xla_ops.xla_spmd_shard_to_full_shape
+
+
+@ops.RegisterGradient("XlaSpmdFullToShardShape")
+def _spmd_full_to_shard_shape_grad(op, grad):
+  s2f = gen_xla_ops.xla_spmd_shard_to_full_shape(
+      grad,
+      manual_sharding=op.get_attr("manual_sharding"),
+      full_shape=op.inputs[0].shape.as_list(),
+      dim=op.get_attr("dim"),
+      unspecified_dims=op.get_attr("unspecified_dims"),
+  )
+  return [s2f]
+
+
+@ops.RegisterGradient("XlaSpmdShardToFullShape")
+def _spmd_shard_to_full_shape_grad(op, grad):
+  f2s = gen_xla_ops.xla_spmd_full_to_shard_shape(
+      grad,
+      manual_sharding=op.get_attr("manual_sharding"),
+      dim=op.get_attr("dim"),
+      unspecified_dims=op.get_attr("unspecified_dims"),
+  )
+  return [f2s]
+
+
+sort = gen_xla_ops.xla_sort
+key_value_sort = gen_xla_ops.xla_key_value_sort
+variadic_sort = gen_xla_ops.xla_variadic_sort
+while_loop = gen_xla_ops.xla_while
+dequantize = gen_xla_ops.xla_dequantize
+custom_call = gen_xla_ops.xla_custom_call
+
+
+def custom_call_v2(
+    call_target_name,
+    operands,
+    result_specs,
+    backend_config=None,
+    has_side_effect=None,
+    name=None,
+):
+  """Emits an HLO `CustomCall` operation with multiple outputs.
+
+  See `CustomCall` specification at
+    https://tensorflow.org/xla/operation_semantics#customcall,
+  and `mhlo.custom_call` specification at
+    https://tensorflow.org/mlir/hlo_ops#mhlocustom_call_mlirmhlocustomcallop.
+
+  Args:
+    call_target_name: Name of the user function. The function signature must
+      conform to version 3 of the API, see
+      `API_VERSION_STATUS_RETURNING_UNIFIED`. All operands and results assumed
+      to be in the default layout.
+    operands: A sequence of tensors with possibly different types.
+    result_specs: A sequence of tensor specs for all results.
+    backend_config: A string that encodes a metadata for the backend. Empty
+      string by default.
+    has_side_effect: Indicates whether the custom call has side effects. `False`
+      by default.
+    name: Optional name of the operation.
+
+  Returns:
+    A tuple of output tensors.
+  """
+  return gen_xla_ops.xla_custom_call_v2(
+      operands=operands,
+      call_target_name=call_target_name,
+      backend_config="" if backend_config is None else backend_config,
+      has_side_effect=False if has_side_effect is None else has_side_effect,
+      result_dtypes=tuple(spec.dtype for spec in result_specs),
+      result_shapes=tuple(spec.shape for spec in result_specs),
+      name=name,
+  )
+
+
+# pylint: disable=g-doc-args
+# pylint: disable=g-doc-return-or-yield
+def call_module(
+    args,
+    *,
+    version=4,
+    module,
+    Tout,
+    Sout,
+    platforms=(),
+    function_list=(),
+    has_token_input_output=False,
+    disabled_checks=(),
+):
+  """See documentation for the XlaCallModule op.
+
+  https://github.com/search?q=repo%3Atensorflow%2Ftensorflow+path%3Axla_ops.cc+xlacallmodule&type=code
+  """
+  res = gen_xla_ops.xla_call_module(
+      args,
+      version=version,
+      module=module,
+      dim_args_spec=(),
+      Tout=Tout,
+      Sout=Sout,
+      platforms=platforms,
+      function_list=function_list,
+      has_token_input_output=has_token_input_output,
+      disabled_checks=disabled_checks,
+  )
+  # Since XLACallModule op is stateful, zero return function will return the TF
+  # op under tf.function. It creates trouble for downstream codes.
+  # Here we force it return empty tuple to work around it.
+  # TODO(johnqiangzhang): Figure out a better way to handle control dependency.
+  if isinstance(res, ops.Operation):
+    res = ()
+  return res
+
+
+def call_module_maximum_supported_version():
+  """Maximum version of XlaCallModule op supported.
+
+  See versioning details documentation for the XlaCallModule op at:
+  https://github.com/search?q=repo%3Atensorflow%2Ftensorflow+path%3Axla_call_module+%22int+VERSION_MAXIMUM_SUPPORTED%22&type=code
+  """
+  return 9
+
+# pylint: enable=g-doc-args
+# pylint: enable=g-doc-return-or-yield
+
+
+def call_module_disable_check_platform():
+  # For use with xla_call_module.disabled_checks.
+  return "platform"
+
+
+def gather(
+    operand,
+    start_indices,
+    dimension_numbers,
+    slice_sizes,
+    indices_are_sorted=False,
+    name=None,
+):
+  return gen_xla_ops.xla_gather(
+      operand,
+      start_indices,
+      slice_sizes=slice_sizes,
+      dimension_numbers=dimension_numbers.SerializeToString(),
+      indices_are_sorted=indices_are_sorted,
+      name=name,
+  )
+
+
+def scatter(
+    operand,
+    scatter_indices,
+    updates,
+    update_computation,
+    dimension_numbers,
+    indices_are_sorted=False,
+    name=None,
+):
+  return gen_xla_ops.xla_scatter(
+      operand,
+      scatter_indices,
+      updates,
+      update_computation=update_computation,
+      dimension_numbers=dimension_numbers.SerializeToString(),
+      indices_are_sorted=indices_are_sorted,
+      name=name,
+  )
+
+
+def optimization_barrier(*args):
+  return gen_xla_ops.xla_optimization_barrier(args)
+
+
+def reduce_precision(operand, exponent_bits, mantissa_bits):
+  return gen_xla_ops.xla_reduce_precision(operand, exponent_bits, mantissa_bits)

videochat2/lib/python3.10/site-packages/tensorflow/compiler/tf2xla/tf2xla_pb2.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/compiler/tf2xla/tf2xla.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from tensorflow.core.framework import tensor_shape_pb2 as tensorflow_dot_core_dot_framework_dot_tensor__shape__pb2
+from tensorflow.core.framework import types_pb2 as tensorflow_dot_core_dot_framework_dot_types__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\'tensorflow/compiler/tf2xla/tf2xla.proto\x12\x11tensorflow.tf2xla\x1a,tensorflow/core/framework/tensor_shape.proto\x1a%tensorflow/core/framework/types.proto\"3\n\x08TensorId\x12\x11\n\tnode_name\x18\x01 \x01(\t\x12\x14\n\x0coutput_index\x18\x02 \x01(\x03\"\x8e\x01\n\x04\x46\x65\x65\x64\x12\'\n\x02id\x18\x01 \x01(\x0b\x32\x1b.tensorflow.tf2xla.TensorId\x12+\n\x05shape\x18\x02 \x01(\x0b\x32\x1c.tensorflow.TensorShapeProto\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\"\n\x04type\x18\x04 \x01(\x0e\x32\x14.tensorflow.DataType\"\x8f\x01\n\x05\x46\x65tch\x12\'\n\x02id\x18\x01 \x01(\x0b\x32\x1b.tensorflow.tf2xla.TensorId\x12\x0c\n\x04name\x18\x02 \x01(\t\x12+\n\x05shape\x18\x03 \x01(\x0b\x32\x1c.tensorflow.TensorShapeProto\x12\"\n\x04type\x18\x04 \x01(\x0e\x32\x14.tensorflow.DataType\"\x8e\x01\n\x08Variable\x12\x11\n\tnode_name\x18\x01 \x01(\t\x12\x0c\n\x04name\x18\x02 \x01(\t\x12+\n\x05shape\x18\x03 \x01(\x0b\x32\x1c.tensorflow.TensorShapeProto\x12\"\n\x04type\x18\x04 \x01(\x0e\x32\x14.tensorflow.DataType\x12\x10\n\x08readonly\x18\x05 \x01(\x08\"\x87\x01\n\x06\x43onfig\x12%\n\x04\x66\x65\x65\x64\x18\x01 \x03(\x0b\x32\x17.tensorflow.tf2xla.Feed\x12\'\n\x05\x66\x65tch\x18\x02 \x03(\x0b\x32\x18.tensorflow.tf2xla.Fetch\x12-\n\x08variable\x18\x03 \x03(\x0b\x32\x1b.tensorflow.tf2xla.VariableB*\n\x15org.tensorflow.tf2xlaB\x0cTf2XlaProtosP\x01\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'tensorflow.compiler.tf2xla.tf2xla_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\025org.tensorflow.tf2xlaB\014Tf2XlaProtosP\001\370\001\001'
+  _TENSORID._serialized_start=147
+  _TENSORID._serialized_end=198
+  _FEED._serialized_start=201
+  _FEED._serialized_end=343
+  _FETCH._serialized_start=346
+  _FETCH._serialized_end=489
+  _VARIABLE._serialized_start=492
+  _VARIABLE._serialized_end=634
+  _CONFIG._serialized_start=637
+  _CONFIG._serialized_end=772
+# @@protoc_insertion_point(module_scope)

videochat2/lib/python3.10/site-packages/tensorflow/compiler/xla/service/hlo_pb2.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: xla/service/hlo.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2
+from tensorflow.compiler.xla import xla_data_pb2 as xla_dot_xla__data__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15xla/service/hlo.proto\x12\x03xla\x1a\x19google/protobuf/any.proto\x1a\x12xla/xla_data.proto\"\xc5\x16\n\x13HloInstructionProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06opcode\x18\x02 \x01(\t\x12\x1e\n\x05shape\x18\x03 \x01(\x0b\x32\x0f.xla.ShapeProto\x12!\n\x08metadata\x18\x07 \x01(\x0b\x32\x0f.xla.OpMetadata\x12\"\n\x07literal\x18\x08 \x01(\x0b\x32\x11.xla.LiteralProto\x12\x18\n\x10parameter_number\x18\t \x01(\x03\x12\x13\n\x0b\x66usion_kind\x18\x0b \x01(\t\x12\x13\n\x0btuple_index\x18\r \x01(\x03\x12\x12\n\ndimensions\x18\x0e \x03(\x03\x12\x1b\n\x06window\x18\x0f \x01(\x0b\x32\x0b.xla.Window\x12G\n\x1d\x63onvolution_dimension_numbers\x18\x10 \x01(\x0b\x32 .xla.ConvolutionDimensionNumbers\x12\x1b\n\x13\x66\x65\x61ture_group_count\x18\x32 \x01(\x03\x12\x19\n\x11\x62\x61tch_group_count\x18: \x01(\x03\x12\x42\n\x10slice_dimensions\x18\x11 \x03(\x0b\x32(.xla.HloInstructionProto.SliceDimensions\x12\x15\n\rexponent_bits\x18\x12 \x01(\x05\x12\x15\n\rmantissa_bits\x18\x13 \x01(\x05\x12\x1b\n\x13\x64ynamic_slice_sizes\x18\x14 \x03(\x03\x12*\n\x0epadding_config\x18\x15 \x01(\x0b\x32\x12.xla.PaddingConfig\x12\x16\n\x0eoutfeed_config\x18\x16 \x01(\x0c\x12-\n\x0c\x64istribution\x18\x17 \x01(\x0e\x32\x17.xla.RandomDistribution\x12\x0f\n\x07\x65psilon\x18\x18 \x01(\x02\x12\x15\n\rfeature_index\x18\x19 \x01(\x03\x12\x12\n\nchannel_id\x18\x1a \x01(\x03\x12\x15\n\rinfeed_config\x18\x1b \x01(\x0c\x12\x1a\n\x12\x63ustom_call_target\x18\x1c \x01(\t\x12&\n\routfeed_shape\x18\x1d \x01(\x0b\x32\x0f.xla.ShapeProto\x12\x37\n\x15\x64ot_dimension_numbers\x18\x1e \x01(\x0b\x32\x18.xla.DotDimensionNumbers\x12\x1e\n\x08\x66\x66t_type\x18\x1f \x01(\x0e\x32\x0c.xla.FftType\x12\x12\n\nfft_length\x18  \x03(\x03\x12\x1c\n\x14\x63omparison_direction\x18? \x01(\t\x12=\n\x18gather_dimension_numbers\x18! \x01(\x0b\x32\x1b.xla.GatherDimensionNumbers\x12\x1a\n\x12gather_slice_sizes\x18\" \x03(\x03\x12\n\n\x02id\x18# \x01(\x03\x12\x13\n\x0boperand_ids\x18$ \x03(\x03\x12\x1f\n\x17\x63ontrol_predecessor_ids\x18% \x03(\x03\x12\x1e\n\x16\x63\x61lled_computation_ids\x18& \x03(\x03\x12!\n\x08sharding\x18( \x01(\x0b\x32\x0f.xla.OpSharding\x12\x16\n\x0e\x62\x61\x63kend_config\x18+ \x01(\x0c\x12)\n\x0ereplica_groups\x18\x31 \x03(\x0b\x32\x11.xla.ReplicaGroup\x12\x19\n\rall_reduce_id\x18- \x01(\x03\x42\x02\x18\x01\x12\x1d\n\x15use_global_device_ids\x18G \x01(\x08\x12\x18\n\x10is_host_transfer\x18/ \x01(\x08\x12\x11\n\tis_stable\x18< \x01(\x08\x12?\n\x19scatter_dimension_numbers\x18\x30 \x01(\x0b\x32\x1c.xla.ScatterDimensionNumbers\x12.\n\x10precision_config\x18\x33 \x01(\x0b\x32\x14.xla.PrecisionConfig\x12.\n\x13source_target_pairs\x18\x34 \x03(\x0b\x32\x11.xla.SourceTarget\x12.\n\x15\x64omain_entry_sharding\x18\x36 \x01(\x0b\x32\x0f.xla.OpSharding\x12-\n\x14\x64omain_exit_sharding\x18\x37 \x01(\x0b\x32\x0f.xla.OpSharding\x12\x18\n\x10\x63onstrain_layout\x18\x38 \x01(\x08\x12\x33\n\x1aoperand_shapes_with_layout\x18\x39 \x03(\x0b\x32\x0f.xla.ShapeProto\x12=\n\x18triangular_solve_options\x18; \x01(\x0b\x32\x1b.xla.TriangularSolveOptions\x12.\n\x10\x63holesky_options\x18> \x01(\x0b\x32\x14.xla.CholeskyOptions\x12\x38\n\x15parameter_replication\x18= \x01(\x0b\x32\x19.xla.ParameterReplication\x12#\n\x1b\x63ustom_call_has_side_effect\x18\x41 \x01(\x08\x12;\n\x17output_operand_aliasing\x18J \x03(\x0b\x32\x1a.xla.OutputOperandAliasing\x12\x35\n\x14\x63ustom_call_schedule\x18L \x01(\x0e\x32\x17.xla.CustomCallSchedule\x12\r\n\x05\x64\x65lta\x18\x42 \x01(\x03\x12\x1a\n\x12indices_are_sorted\x18\x43 \x01(\x08\x12\x34\n\x13\x66rontend_attributes\x18\x44 \x01(\x0b\x32\x17.xla.FrontendAttributes\x12\x16\n\x0eunique_indices\x18\x45 \x01(\x08\x12+\n\rrng_algorithm\x18\x46 \x01(\x0e\x32\x14.xla.RandomAlgorithm\x12\x17\n\x0f\x63omparison_type\x18H \x01(\t\x12%\n\x19is_cross_program_prefetch\x18I \x01(\x08\x42\x02\x18\x01\x12&\n\x1c\x63ross_program_prefetch_index\x18P \x01(\x05H\x00\x12&\n\x0cpadding_type\x18K \x01(\x0e\x32\x10.xla.PaddingType\x12:\n\x17\x63ustom_call_api_version\x18M \x01(\x0e\x32\x19.xla.CustomCallApiVersion\x12\x1e\n\x16\x61sync_execution_thread\x18O \x01(\t\x12\t\n\x01k\x18Q \x01(\x03\x12\x0f\n\x07largest\x18U \x01(\x08\x12*\n\x0estatistics_viz\x18R \x01(\x0b\x32\x12.xla.StatisticsViz\x12-\n\x0c\x64ot_sparsity\x18V \x01(\x0b\x32\x17.xla.SparsityDescriptor\x1a?\n\x0fSliceDimensions\x12\r\n\x05start\x18\x01 \x01(\x03\x12\r\n\x05limit\x18\x02 \x01(\x03\x12\x0e\n\x06stride\x18\x03 \x01(\x03\x42\'\n%optional_cross_program_prefetch_indexJ\x04\x08\n\x10\x0bJ\x04\x08\x0c\x10\rJ\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\x04\x08,\x10-J\x04\x08\x35\x10\x36J\x04\x08.\x10/J\x04\x08)\x10*J\x04\x08*\x10+J\x04\x08@\x10\x41J\x04\x08N\x10OJ\x04\x08S\x10TJ\x04\x08T\x10UR\x0eparameter_nameR\x1e\x66used_instructions_computationR\roperand_namesR\x19\x63ontrol_predecessor_namesR\x18\x63\x61lled_computation_namesR\x11replica_group_idsR\x12\x63ustom_call_opaqueR\x12\x61ll_reduce_barrier\"\xe9\x01\n\x13HloComputationProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12.\n\x0cinstructions\x18\x02 \x03(\x0b\x32\x18.xla.HloInstructionProto\x12-\n\rprogram_shape\x18\x04 \x01(\x0b\x32\x16.xla.ProgramShapeProto\x12\n\n\x02id\x18\x05 \x01(\x03\x12\x0f\n\x07root_id\x18\x06 \x01(\x03\x12\x1d\n\x15is_fusion_computation\x18\x07 \x01(\x08\x12\x18\n\x10\x65xecution_thread\x18\x08 \x01(\tJ\x04\x08\x03\x10\x04R\troot_name\"\xd8\x01\n\x10HloScheduleProto\x12\x37\n\tsequences\x18\x01 \x03(\x0b\x32$.xla.HloScheduleProto.SequencesEntry\x1a.\n\x13InstructionSequence\x12\x17\n\x0finstruction_ids\x18\x01 \x03(\x03\x1a[\n\x0eSequencesEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).xla.HloScheduleProto.InstructionSequence:\x02\x38\x01\"\xdb\x01\n\x18HloInputOutputAliasProto\x12>\n\x07\x65ntries\x18\x01 \x03(\x0b\x32-.xla.HloInputOutputAliasProto.AliasEntryProto\x1a\x7f\n\x0f\x41liasEntryProto\x12\x1a\n\x12output_shape_index\x18\x01 \x03(\x03\x12\x18\n\x10parameter_number\x18\x02 \x01(\x03\x12\x1d\n\x15parameter_shape_index\x18\x03 \x03(\x03\x12\x17\n\x04kind\x18\x04 \x01(\x0e\x32\t.xla.Kind\"\xa8\x01\n\x13HloBufferDonorProto\x12?\n\x07\x65ntries\x18\x01 \x03(\x0b\x32..xla.HloBufferDonorProto.BufferDonorEntryProto\x1aP\n\x15\x42ufferDonorEntryProto\x12\x18\n\x10parameter_number\x18\x01 \x01(\x03\x12\x1d\n\x15parameter_shape_index\x18\x02 \x03(\x03\"H\n\x14\x43rossProgramPrefetch\x12\x11\n\tparameter\x18\x01 \x01(\x03\x12\r\n\x05index\x18\x02 \x03(\x03\x12\x0e\n\x06offset\x18\x03 \x01(\x03\"\xdd\x02\n\x14StackFrameIndexProto\x12\x12\n\nfile_names\x18\x01 \x03(\t\x12\x16\n\x0e\x66unction_names\x18\x02 \x03(\t\x12>\n\x0e\x66ile_locations\x18\x03 \x03(\x0b\x32&.xla.StackFrameIndexProto.FileLocation\x12:\n\x0cstack_frames\x18\x04 \x03(\x0b\x32$.xla.StackFrameIndexProto.StackFrame\x1a\\\n\x0c\x46ileLocation\x12\x14\n\x0c\x66ile_name_id\x18\x01 \x01(\x05\x12\x18\n\x10\x66unction_name_id\x18\x02 \x01(\x05\x12\x0c\n\x04line\x18\x03 \x01(\x05\x12\x0e\n\x06\x63olumn\x18\x04 \x01(\x05\x1a?\n\nStackFrame\x12\x18\n\x10\x66ile_location_id\x18\x01 \x01(\x05\x12\x17\n\x0fparent_frame_id\x18\x02 \x01(\x05\"\xce\x08\n\x0eHloModuleProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1e\n\x16\x65ntry_computation_name\x18\x02 \x01(\t\x12\x1c\n\x14\x65ntry_computation_id\x18\x06 \x01(\x03\x12.\n\x0c\x63omputations\x18\x03 \x03(\x0b\x32\x18.xla.HloComputationProto\x12\x32\n\x12host_program_shape\x18\x04 \x01(\x0b\x32\x16.xla.ProgramShapeProto\x12\n\n\x02id\x18\x05 \x01(\x03\x12\'\n\x08schedule\x18\x07 \x01(\x0b\x32\x15.xla.HloScheduleProto\x12\x39\n\x12input_output_alias\x18\x08 \x01(\x0b\x32\x1d.xla.HloInputOutputAliasProto\x12.\n\x0c\x62uffer_donor\x18\x12 \x01(\x0b\x32\x18.xla.HloBufferDonorProto\x12;\n\x18\x63ross_program_prefetches\x18\n \x03(\x0b\x32\x19.xla.CrossProgramPrefetch\x12\x12\n\nis_dynamic\x18\x0b \x01(\x08\x12-\n\x14spmd_output_sharding\x18\x0c \x01(\x0b\x32\x0f.xla.OpSharding\x12\x32\n\x19spmd_parameters_shardings\x18\x0e \x03(\x0b\x32\x0f.xla.OpSharding\x12\"\n\x1ause_auto_spmd_partitioning\x18\x10 \x01(\x08\x12\x35\n\x0cprofile_info\x18\r \x03(\x0b\x32\x1f.xla.HloModuleProto.ProfileInfo\x12\x35\n\x11\x64\x65vice_assignment\x18\x0f \x01(\x0b\x32\x1a.xla.DeviceAssignmentProto\x12\x34\n\x11stack_frame_index\x18\x11 \x01(\x0b\x32\x19.xla.StackFrameIndexProto\x12\x34\n\x13\x66rontend_attributes\x18\x13 \x01(\x0b\x32\x17.xla.FrontendAttributes\x1a\xd1\x01\n\x0bProfileInfo\x12\x35\n\x0cprofile_type\x18\x01 \x01(\x0e\x32\x1f.xla.HloModuleProto.ProfileType\x12\x18\n\x10relative_speedup\x18\x02 \x01(\x01\x12*\n\x0eprofile_source\x18\x03 \x01(\x0e\x32\x12.xla.ProfileSource\x12\x30\n\x11\x63ompilation_event\x18\x04 \x01(\x0e\x32\x15.xla.CompilationEvent\x12\x13\n\x0b\x66ingerprint\x18\x05 \x01(\t\"E\n\x0bProfileType\x12\x0b\n\x07INVALID\x10\x00\x12\x08\n\x04\x46LAG\x10\x01\x12\n\n\x06\x46USION\x10\x02\x12\n\n\x06LAYOUT\x10\x03\x12\x07\n\x03\x44OT\x10\x04J\x04\x08\t\x10\nR\x19\x64ynamic_parameter_binding\"\xd0\x01\n\x12LogicalBufferProto\x12\n\n\x02id\x18\x01 \x01(\x03\x12\x0c\n\x04size\x18\x02 \x01(\x03\x12\x34\n\ndefined_at\x18\x03 \x01(\x0b\x32 .xla.LogicalBufferProto.Location\x12\r\n\x05\x63olor\x18\x04 \x01(\x03\x1a[\n\x08Location\x12\x1c\n\x10instruction_name\x18\x02 \x01(\tB\x02\x18\x01\x12\x16\n\x0einstruction_id\x18\x04 \x01(\x03\x12\x13\n\x0bshape_index\x18\x03 \x03(\x03J\x04\x08\x01\x10\x02\"\xf8\x02\n\x15\x42ufferAllocationProto\x12\r\n\x05index\x18\x01 \x01(\x03\x12\x0c\n\x04size\x18\x02 \x01(\x03\x12\x17\n\x0fis_thread_local\x18\x03 \x01(\x08\x12\x10\n\x08is_tuple\x18\x0b \x01(\x08\x12&\n\x1eis_entry_computation_parameter\x18\x05 \x01(\x08\x12\x13\n\x0bis_constant\x18\x0c \x01(\x08\x12\x18\n\x10parameter_number\x18\x06 \x01(\x03\x12\x1d\n\x15parameter_shape_index\x18\n \x03(\x03\x12\x16\n\x0emaybe_live_out\x18\x07 \x01(\x08\x12\r\n\x05\x63olor\x18\x08 \x01(\x03\x12\x35\n\x08\x61ssigned\x18\t \x03(\x0b\x32#.xla.BufferAllocationProto.Assigned\x1a\x43\n\x08\x41ssigned\x12\x19\n\x11logical_buffer_id\x18\x01 \x01(\x03\x12\x0e\n\x06offset\x18\x02 \x01(\x03\x12\x0c\n\x04size\x18\x03 \x01(\x03\"\xd6\x02\n\x12HeapSimulatorTrace\x12-\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x1d.xla.HeapSimulatorTrace.Event\x12\x1f\n\x17whole_module_simulation\x18\x02 \x01(\x08\x12\x1f\n\x17\x62uffer_allocation_index\x18\x03 \x01(\x03\x1a\xce\x01\n\x05\x45vent\x12\x30\n\x04kind\x18\x01 \x01(\x0e\x32\".xla.HeapSimulatorTrace.Event.Kind\x12\x11\n\tbuffer_id\x18\x02 \x01(\x03\x12\x18\n\x10\x63omputation_name\x18\x03 \x01(\t\x12\x18\n\x10instruction_name\x18\x04 \x01(\t\x12\x1f\n\x17share_with_canonical_id\x18\x05 \x01(\x03\"+\n\x04Kind\x12\t\n\x05\x41LLOC\x10\x00\x12\x08\n\x04\x46REE\x10\x01\x12\x0e\n\nSHARE_WITH\x10\x02\"M\n\x13HloModuleGroupProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x0bhlo_modules\x18\x02 \x03(\x0b\x32\x13.xla.HloModuleProto\"\xd6\x02\n\x15\x42ufferAssignmentProto\x12\x30\n\x0flogical_buffers\x18\x01 \x03(\x0b\x32\x17.xla.LogicalBufferProto\x12>\n\x0e\x62uffer_aliases\x18\x02 \x03(\x0b\x32&.xla.BufferAssignmentProto.BufferAlias\x12\x36\n\x12\x62uffer_allocations\x18\x03 \x03(\x0b\x32\x1a.xla.BufferAllocationProto\x12\x36\n\x15heap_simulator_traces\x18\x04 \x03(\x0b\x32\x17.xla.HeapSimulatorTrace\x1a[\n\x0b\x42ufferAlias\x12\x18\n\x10source_buffer_id\x18\x01 \x01(\x03\x12\x32\n\x08location\x18\x02 \x01(\x0b\x32 .xla.LogicalBufferProto.Location\"~\n\x08HloProto\x12\'\n\nhlo_module\x18\x01 \x01(\x0b\x32\x13.xla.HloModuleProto\x12\x35\n\x11\x62uffer_assignment\x18\x03 \x01(\x0b\x32\x1a.xla.BufferAssignmentProtoJ\x04\x08\x02\x10\x03R\x0chlo_ordering\"\x8e\x01\n\x0bHloSnapshot\x12\x1a\n\x03hlo\x18\x01 \x01(\x0b\x32\r.xla.HloProto\x12$\n\targuments\x18\x02 \x03(\x0b\x32\x11.xla.LiteralProto\x12!\n\x06result\x18\x03 \x01(\x0b\x32\x11.xla.LiteralProto\x12\x1a\n\x12\x65xecution_platform\x18\x04 \x01(\t\"\xb9\x01\n\x16HloModuleMetadataProto\x12\x1b\n\x13\x63\x61nonical_module_id\x18\x01 \x01(\x03\x12\x19\n\x11module_group_name\x18\x02 \x01(\t\x12\x1a\n\x12original_module_id\x18\x03 \x01(\x03\x12\x1e\n\x16partitioned_module_ids\x18\x04 \x03(\x03\x12+\n\rpass_metadata\x18\x05 \x03(\x0b\x32\x14.xla.HloPassMetadata\"\x99\x02\n\x0fHloPassMetadata\x12\x0f\n\x07pass_id\x18\x01 \x01(\x03\x12\x11\n\tpass_name\x18\x02 \x01(\t\x12\x15\n\rpipeline_name\x18\x03 \x01(\t\x12\x16\n\x0e\x64ump_filenames\x18\x04 \x03(\t\x12\x16\n\x0emodule_changed\x18\x05 \x01(\x08\x12\x11\n\tmodule_id\x18\x06 \x01(\x03\x12\x1f\n\x17module_group_module_ids\x18\x07 \x03(\x03\x12\x1c\n\x14start_timestamp_usec\x18\x08 \x01(\x03\x12\x1a\n\x12\x65nd_timestamp_usec\x18\t \x01(\x03\x12-\n\x0f\x63ustom_metadata\x18\n \x01(\x0b\x32\x14.google.protobuf.Any\"q\n\x19XlaRuntimeExecutableProto\x12-\n\x10hlo_module_proto\x18\x01 \x01(\x0b\x32\x13.xla.HloModuleProto\x12\x10\n\x08obj_file\x18\x03 \x01(\x0c\x12\x13\n\x0bmlir_module\x18\x04 \x01(\t*S\n\x12\x43ustomCallSchedule\x12\x11\n\rSCHEDULE_NONE\x10\x00\x12\x13\n\x0fSCHEDULE_LATEST\x10\x01\x12\x15\n\x11SCHEDULE_EARLIEST\x10\x02*\xb4\x01\n\x14\x43ustomCallApiVersion\x12\x1b\n\x17\x41PI_VERSION_UNSPECIFIED\x10\x00\x12\x18\n\x14\x41PI_VERSION_ORIGINAL\x10\x01\x12 \n\x1c\x41PI_VERSION_STATUS_RETURNING\x10\x02\x12(\n$API_VERSION_STATUS_RETURNING_UNIFIED\x10\x03\x12\x19\n\x15\x41PI_VERSION_TYPED_FFI\x10\x04*:\n\x04Kind\x12\x13\n\x0fUNDEFINED_ALIAS\x10\x00\x12\r\n\tMAY_ALIAS\x10\x01\x12\x0e\n\nMUST_ALIAS\x10\x02\x42\x03\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'xla.service.hlo_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _HLOINSTRUCTIONPROTO.fields_by_name['all_reduce_id']._options = None
+  _HLOINSTRUCTIONPROTO.fields_by_name['all_reduce_id']._serialized_options = b'\030\001'
+  _HLOINSTRUCTIONPROTO.fields_by_name['is_cross_program_prefetch']._options = None
+  _HLOINSTRUCTIONPROTO.fields_by_name['is_cross_program_prefetch']._serialized_options = b'\030\001'
+  _HLOSCHEDULEPROTO_SEQUENCESENTRY._options = None
+  _HLOSCHEDULEPROTO_SEQUENCESENTRY._serialized_options = b'8\001'
+  _LOGICALBUFFERPROTO_LOCATION.fields_by_name['instruction_name']._options = None
+  _LOGICALBUFFERPROTO_LOCATION.fields_by_name['instruction_name']._serialized_options = b'\030\001'
+  _CUSTOMCALLSCHEDULE._serialized_start=7563
+  _CUSTOMCALLSCHEDULE._serialized_end=7646
+  _CUSTOMCALLAPIVERSION._serialized_start=7649
+  _CUSTOMCALLAPIVERSION._serialized_end=7829
+  _KIND._serialized_start=7831
+  _KIND._serialized_end=7889
+  _HLOINSTRUCTIONPROTO._serialized_start=78
+  _HLOINSTRUCTIONPROTO._serialized_end=2963
+  _HLOINSTRUCTIONPROTO_SLICEDIMENSIONS._serialized_start=2600
+  _HLOINSTRUCTIONPROTO_SLICEDIMENSIONS._serialized_end=2663
+  _HLOCOMPUTATIONPROTO._serialized_start=2966
+  _HLOCOMPUTATIONPROTO._serialized_end=3199
+  _HLOSCHEDULEPROTO._serialized_start=3202
+  _HLOSCHEDULEPROTO._serialized_end=3418
+  _HLOSCHEDULEPROTO_INSTRUCTIONSEQUENCE._serialized_start=3279
+  _HLOSCHEDULEPROTO_INSTRUCTIONSEQUENCE._serialized_end=3325
+  _HLOSCHEDULEPROTO_SEQUENCESENTRY._serialized_start=3327
+  _HLOSCHEDULEPROTO_SEQUENCESENTRY._serialized_end=3418
+  _HLOINPUTOUTPUTALIASPROTO._serialized_start=3421
+  _HLOINPUTOUTPUTALIASPROTO._serialized_end=3640
+  _HLOINPUTOUTPUTALIASPROTO_ALIASENTRYPROTO._serialized_start=3513
+  _HLOINPUTOUTPUTALIASPROTO_ALIASENTRYPROTO._serialized_end=3640
+  _HLOBUFFERDONORPROTO._serialized_start=3643
+  _HLOBUFFERDONORPROTO._serialized_end=3811
+  _HLOBUFFERDONORPROTO_BUFFERDONORENTRYPROTO._serialized_start=3731
+  _HLOBUFFERDONORPROTO_BUFFERDONORENTRYPROTO._serialized_end=3811
+  _CROSSPROGRAMPREFETCH._serialized_start=3813
+  _CROSSPROGRAMPREFETCH._serialized_end=3885
+  _STACKFRAMEINDEXPROTO._serialized_start=3888
+  _STACKFRAMEINDEXPROTO._serialized_end=4237
+  _STACKFRAMEINDEXPROTO_FILELOCATION._serialized_start=4080
+  _STACKFRAMEINDEXPROTO_FILELOCATION._serialized_end=4172
+  _STACKFRAMEINDEXPROTO_STACKFRAME._serialized_start=4174
+  _STACKFRAMEINDEXPROTO_STACKFRAME._serialized_end=4237
+  _HLOMODULEPROTO._serialized_start=4240
+  _HLOMODULEPROTO._serialized_end=5342
+  _HLOMODULEPROTO_PROFILEINFO._serialized_start=5029
+  _HLOMODULEPROTO_PROFILEINFO._serialized_end=5238
+  _HLOMODULEPROTO_PROFILETYPE._serialized_start=5240
+  _HLOMODULEPROTO_PROFILETYPE._serialized_end=5309
+  _LOGICALBUFFERPROTO._serialized_start=5345
+  _LOGICALBUFFERPROTO._serialized_end=5553
+  _LOGICALBUFFERPROTO_LOCATION._serialized_start=5462
+  _LOGICALBUFFERPROTO_LOCATION._serialized_end=5553
+  _BUFFERALLOCATIONPROTO._serialized_start=5556
+  _BUFFERALLOCATIONPROTO._serialized_end=5932
+  _BUFFERALLOCATIONPROTO_ASSIGNED._serialized_start=5865
+  _BUFFERALLOCATIONPROTO_ASSIGNED._serialized_end=5932
+  _HEAPSIMULATORTRACE._serialized_start=5935
+  _HEAPSIMULATORTRACE._serialized_end=6277
+  _HEAPSIMULATORTRACE_EVENT._serialized_start=6071
+  _HEAPSIMULATORTRACE_EVENT._serialized_end=6277
+  _HEAPSIMULATORTRACE_EVENT_KIND._serialized_start=6234
+  _HEAPSIMULATORTRACE_EVENT_KIND._serialized_end=6277
+  _HLOMODULEGROUPPROTO._serialized_start=6279
+  _HLOMODULEGROUPPROTO._serialized_end=6356
+  _BUFFERASSIGNMENTPROTO._serialized_start=6359
+  _BUFFERASSIGNMENTPROTO._serialized_end=6701
+  _BUFFERASSIGNMENTPROTO_BUFFERALIAS._serialized_start=6610
+  _BUFFERASSIGNMENTPROTO_BUFFERALIAS._serialized_end=6701
+  _HLOPROTO._serialized_start=6703
+  _HLOPROTO._serialized_end=6829
+  _HLOSNAPSHOT._serialized_start=6832
+  _HLOSNAPSHOT._serialized_end=6974
+  _HLOMODULEMETADATAPROTO._serialized_start=6977
+  _HLOMODULEMETADATAPROTO._serialized_end=7162
+  _HLOPASSMETADATA._serialized_start=7165
+  _HLOPASSMETADATA._serialized_end=7446
+  _XLARUNTIMEEXECUTABLEPROTO._serialized_start=7448
+  _XLARUNTIMEEXECUTABLEPROTO._serialized_end=7561
+# @@protoc_insertion_point(module_scope)

videochat2/lib/python3.10/site-packages/tensorflow/compiler/xla/xla_data_pb2.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: xla/xla_data.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12xla/xla_data.proto\x12\x03xla\"\xb7\x01\n\rPaddingConfig\x12=\n\ndimensions\x18\x01 \x03(\x0b\x32).xla.PaddingConfig.PaddingConfigDimension\x1ag\n\x16PaddingConfigDimension\x12\x18\n\x10\x65\x64ge_padding_low\x18\x01 \x01(\x03\x12\x19\n\x11\x65\x64ge_padding_high\x18\x02 \x01(\x03\x12\x18\n\x10interior_padding\x18\x03 \x01(\x03\"\x1f\n\tTileProto\x12\x12\n\ndimensions\x18\x01 \x03(\x03\"\x8c\x04\n\x0bLayoutProto\x12*\n\x0f\x64im_level_types\x18\t \x03(\x0e\x32\x11.xla.DimLevelType\x12\x12\n\ndim_unique\x18\r \x03(\x08\x12\x13\n\x0b\x64im_ordered\x18\x0e \x03(\x08\x12\x16\n\x0eminor_to_major\x18\x01 \x03(\x03\x12\x1d\n\x05tiles\x18\x06 \x03(\x0b\x32\x0e.xla.TileProto\x12*\n\"tail_padding_alignment_in_elements\x18\x10 \x01(\x03\x12\x1c\n\x14\x65lement_size_in_bits\x18\x07 \x01(\x03\x12\x14\n\x0cmemory_space\x18\x08 \x01(\x03\x12\x30\n\x14index_primitive_type\x18\x0b \x01(\x0e\x32\x12.xla.PrimitiveType\x12\x32\n\x16pointer_primitive_type\x18\x0c \x01(\x0e\x32\x12.xla.PrimitiveType\x12\'\n\x0ephysical_shape\x18\n \x01(\x0b\x32\x0f.xla.ShapeProto\x12+\n#dynamic_shape_metadata_prefix_bytes\x18\x0f \x01(\x03J\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06R\x11padded_dimensionsR\rpadding_valueR\x06\x66ormatR\x13max_sparse_elements\"\xbd\x01\n\nShapeProto\x12(\n\x0c\x65lement_type\x18\x02 \x01(\x0e\x32\x12.xla.PrimitiveType\x12\x12\n\ndimensions\x18\x03 \x03(\x03\x12%\n\x0ctuple_shapes\x18\x04 \x03(\x0b\x32\x0f.xla.ShapeProto\x12 \n\x06layout\x18\x05 \x01(\x0b\x32\x10.xla.LayoutProto\x12\x1c\n\x14is_dynamic_dimension\x18\x06 \x03(\x08J\x04\x08\x01\x10\x02R\x04rank\"r\n\x11ProgramShapeProto\x12#\n\nparameters\x18\x01 \x03(\x0b\x32\x0f.xla.ShapeProto\x12\x1f\n\x06result\x18\x02 \x01(\x0b\x32\x0f.xla.ShapeProto\x12\x17\n\x0fparameter_names\x18\x03 \x03(\t\"D\n\x10\x43omputationStats\x12\x12\n\nflop_count\x18\x01 \x01(\x01\x12\x1c\n\x14transcendental_count\x18\x02 \x01(\x01\"\xcb\x04\n\nOpMetadata\x12\x0f\n\x07op_type\x18\x01 \x01(\t\x12\x0f\n\x07op_name\x18\x02 \x01(\t\x12\x13\n\x0bsource_file\x18\x03 \x01(\t\x12\x13\n\x0bsource_line\x18\x04 \x01(\x05\x12*\n\x0cprofile_type\x18\x05 \x03(\x0e\x32\x10.xla.ProfileTypeB\x02\x18\x01\x12\x18\n\x10\x63reation_pass_id\x18\x06 \x01(\x03\x12 \n\x18logical_creation_pass_id\x18\x07 \x01(\x03\x12\'\n\x1fsize_of_generated_code_in_bytes\x18\x08 \x01(\x03\x12+\n#size_of_memory_working_set_in_bytes\x18\t \x01(\x03\x12\x31\n\x0cprofile_info\x18\n \x01(\x0b\x32\x1b.xla.OpMetadata.ProfileInfo\x12\x19\n\x11\x64\x65\x64uplicated_name\x18\x0c \x01(\t\x12\x17\n\x0fpreserve_layout\x18\r \x01(\x08\x12\x16\n\x0estack_frame_id\x18\x0f \x01(\x05\x1a\xad\x01\n\x0bProfileInfo\x12&\n\x0cprofile_type\x18\x01 \x03(\x0e\x32\x10.xla.ProfileType\x12\x18\n\x10relative_speedup\x18\x02 \x01(\x01\x12*\n\x0eprofile_source\x18\x03 \x01(\x0e\x32\x12.xla.ProfileSource\x12\x30\n\x11\x63ompilation_event\x18\x04 \x01(\x0e\x32\x15.xla.CompilationEventJ\x04\x08\x0e\x10\x0f\"\xe3\x01\n\x10\x45xecutionProfile\x12\x1d\n\x15\x63ompilation_cache_hit\x18\x01 \x01(\x08\x12\x17\n\x0f\x63ompile_time_ms\x18\x02 \x01(\x03\x12\x1b\n\x13\x63ompute_cycle_count\x18\x03 \x01(\x03\x12\x17\n\x0f\x63ompute_time_ns\x18\x04 \x01(\x03\x12$\n\x1c\x63ompute_and_transfer_time_ns\x18\x05 \x01(\x03\x12 \n\x18\x65xecutable_size_in_bytes\x18\x06 \x01(\x03\x12\x19\n\x11profile_cache_hit\x18\x07 \x01(\x08\"!\n\x0f\x45xecutionHandle\x12\x0e\n\x06handle\x18\x01 \x01(\x03\"\"\n\x10GlobalDataHandle\x12\x0e\n\x06handle\x18\x01 \x01(\x03\"4\n\x0c\x44\x65viceHandle\x12\x0e\n\x06handle\x18\x01 \x01(\x03\x12\x14\n\x0c\x64\x65vice_count\x18\x02 \x01(\x03\"\xb4\x01\n\rChannelHandle\x12\x0e\n\x06handle\x18\x01 \x01(\x03\x12,\n\x04type\x18\x02 \x01(\x0e\x32\x1e.xla.ChannelHandle.ChannelType\"e\n\x0b\x43hannelType\x12\x18\n\x14\x43HANNEL_TYPE_INVALID\x10\x00\x12\x14\n\x10\x44\x45VICE_TO_DEVICE\x10\x01\x12\x12\n\x0e\x44\x45VICE_TO_HOST\x10\x02\x12\x12\n\x0eHOST_TO_DEVICE\x10\x03\"\xc5\x01\n\x15\x44\x65viceAssignmentProto\x12\x15\n\rreplica_count\x18\x01 \x01(\x05\x12\x19\n\x11\x63omputation_count\x18\x02 \x01(\x05\x12I\n\x13\x63omputation_devices\x18\x03 \x03(\x0b\x32,.xla.DeviceAssignmentProto.ComputationDevice\x1a/\n\x11\x43omputationDevice\x12\x1a\n\x12replica_device_ids\x18\x01 \x03(\x05\"\xc4\x03\n\x0cLiteralProto\x12\x1e\n\x05shape\x18\x01 \x01(\x0b\x32\x0f.xla.ShapeProto\x12\r\n\x05preds\x18\x02 \x03(\x08\x12\x0b\n\x03s4s\x18\x15 \x01(\x0c\x12\x0b\n\x03u4s\x18\x16 \x01(\x0c\x12\x0b\n\x03s8s\x18\x0f \x01(\x0c\x12\x0b\n\x03u8s\x18\x03 \x01(\x0c\x12\x0c\n\x04s32s\x18\x04 \x03(\x05\x12\x0c\n\x04s64s\x18\x05 \x03(\x03\x12\x0c\n\x04u32s\x18\x06 \x03(\r\x12\x0c\n\x04u64s\x18\x07 \x03(\x04\x12\x0c\n\x04\x66\x33\x32s\x18\x08 \x03(\x02\x12\x0c\n\x04\x66\x36\x34s\x18\t \x03(\x01\x12\x0c\n\x04\x63\x36\x34s\x18\x0c \x03(\x02\x12\r\n\x05\x63\x31\x32\x38s\x18\x12 \x03(\x01\x12)\n\x0etuple_literals\x18\n \x03(\x0b\x32\x11.xla.LiteralProto\x12\x0c\n\x04\x66\x31\x36s\x18\x0b \x01(\x0c\x12\r\n\x05\x62\x66\x31\x36s\x18\r \x01(\x0c\x12\x0c\n\x04u16s\x18\x10 \x01(\x0c\x12\x0c\n\x04s16s\x18\x11 \x01(\x0c\x12\x0f\n\x07\x66\x38\x65\x35m2s\x18\x13 \x01(\x0c\x12\x11\n\tf8e4m3fns\x18\x14 \x01(\x0c\x12\x16\n\x0e\x66\x38\x65\x34m3b11fnuzs\x18\x17 \x01(\x0c\x12\x13\n\x0b\x66\x38\x65\x35m2fnuzs\x18\x18 \x01(\x0c\x12\x13\n\x0b\x66\x38\x65\x34m3fnuzs\x18\x19 \x01(\x0c\x12\x16\n\x0esparse_indices\x18\x0e \x03(\x03\"\xa3\x01\n\x0fWindowDimension\x12\x0c\n\x04size\x18\x01 \x01(\x03\x12\x0e\n\x06stride\x18\x02 \x01(\x03\x12\x13\n\x0bpadding_low\x18\x03 \x01(\x03\x12\x14\n\x0cpadding_high\x18\x04 \x01(\x03\x12\x17\n\x0fwindow_dilation\x18\x05 \x01(\x03\x12\x15\n\rbase_dilation\x18\x06 \x01(\x03\x12\x17\n\x0fwindow_reversal\x18\x07 \x01(\x08\"2\n\x06Window\x12(\n\ndimensions\x18\x01 \x03(\x0b\x32\x14.xla.WindowDimension\"~\n\x16GatherDimensionNumbers\x12\x13\n\x0boffset_dims\x18\x01 \x03(\x03\x12\x1c\n\x14\x63ollapsed_slice_dims\x18\x02 \x03(\x03\x12\x17\n\x0fstart_index_map\x18\x03 \x03(\x03\x12\x18\n\x10index_vector_dim\x18\x04 \x01(\x03\"\x93\x01\n\x17ScatterDimensionNumbers\x12\x1a\n\x12update_window_dims\x18\x01 \x03(\x03\x12\x1c\n\x14inserted_window_dims\x18\x02 \x03(\x03\x12$\n\x1cscatter_dims_to_operand_dims\x18\x03 \x03(\x03\x12\x18\n\x10index_vector_dim\x18\x04 \x01(\x03\"\xd8\x02\n\x1b\x43onvolutionDimensionNumbers\x12\x1d\n\x15input_batch_dimension\x18\x07 \x01(\x03\x12\x1f\n\x17input_feature_dimension\x18\x08 \x01(\x03\x12 \n\x18input_spatial_dimensions\x18\x0b \x03(\x03\x12&\n\x1ekernel_input_feature_dimension\x18\x03 \x01(\x03\x12\'\n\x1fkernel_output_feature_dimension\x18\x04 \x01(\x03\x12!\n\x19kernel_spatial_dimensions\x18\x06 \x03(\x03\x12\x1e\n\x16output_batch_dimension\x18\t \x01(\x03\x12 \n\x18output_feature_dimension\x18\n \x01(\x03\x12!\n\x19output_spatial_dimensions\x18\x0c \x03(\x03\"\x99\x01\n\x13\x44otDimensionNumbers\x12\"\n\x1alhs_contracting_dimensions\x18\x01 \x03(\x03\x12\"\n\x1arhs_contracting_dimensions\x18\x02 \x03(\x03\x12\x1c\n\x14lhs_batch_dimensions\x18\x03 \x03(\x03\x12\x1c\n\x14rhs_batch_dimensions\x18\x04 \x03(\x03\"m\n\x12SparsityDescriptor\x12\x1f\n\x04type\x18\x01 \x01(\x0e\x32\x11.xla.SparsityType\x12\r\n\x05index\x18\x02 \x01(\x05\x12\x11\n\tdimension\x18\x03 \x01(\x05\x12\t\n\x01n\x18\x04 \x01(\x05\x12\t\n\x01m\x18\x05 \x01(\x05\"\xdf\x01\n\x16TriangularSolveOptions\x12\x11\n\tleft_side\x18\x01 \x01(\x08\x12\r\n\x05lower\x18\x02 \x01(\x08\x12\x15\n\runit_diagonal\x18\x03 \x01(\x08\x12:\n\x0btranspose_a\x18\x04 \x01(\x0e\x32%.xla.TriangularSolveOptions.Transpose\"P\n\tTranspose\x12\x15\n\x11TRANSPOSE_INVALID\x10\x00\x12\x10\n\x0cNO_TRANSPOSE\x10\x01\x12\r\n\tTRANSPOSE\x10\x02\x12\x0b\n\x07\x41\x44JOINT\x10\x03\" \n\x0f\x43holeskyOptions\x12\r\n\x05lower\x18\x01 \x01(\x08\"!\n\x0bSortOptions\x12\x12\n\ndescending\x18\x01 \x01(\x08\"o\n\x12\x46rontendAttributes\x12-\n\x03map\x18\x01 \x03(\x0b\x32 .xla.FrontendAttributes.MapEntry\x1a*\n\x08MapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"0\n\tStatistic\x12\x11\n\tstat_name\x18\x01 \x01(\t\x12\x10\n\x08stat_val\x18\x02 \x01(\x01\"T\n\rStatisticsViz\x12\x1f\n\x17stat_index_to_visualize\x18\x01 \x01(\x03\x12\"\n\nstatistics\x18\x02 \x03(\x0b\x32\x0e.xla.Statistic\"\xd3\x04\n\nOpSharding\x12\"\n\x04type\x18\x01 \x01(\x0e\x32\x14.xla.OpSharding.Type\x12#\n\ntile_shape\x18\x02 \x01(\x0b\x32\x0f.xla.ShapeProto\x12\"\n\x1atile_assignment_dimensions\x18\x03 \x03(\x03\x12\x1f\n\x17tile_assignment_devices\x18\x04 \x03(\x03\x12(\n\x0ftuple_shardings\x18\x05 \x03(\x0b\x32\x0f.xla.OpSharding\x12\"\n\x1areplicate_on_last_tile_dim\x18\x06 \x01(\x08\x12!\n\x08metadata\x18\x07 \x03(\x0b\x32\x0f.xla.OpMetadata\x12,\n\x0elast_tile_dims\x18\x08 \x03(\x0e\x32\x14.xla.OpSharding.Type\x12\x19\n\x11iota_reshape_dims\x18\t \x03(\x03\x12\x1b\n\x13iota_transpose_perm\x18\n \x03(\x05\x12\x16\n\x0eis_shard_group\x18\x0b \x01(\x08\x12\x16\n\x0eshard_group_id\x18\x0c \x01(\x03\x12\x38\n\x10shard_group_type\x18\r \x01(\x0e\x32\x1e.xla.OpSharding.ShardGroupType\"R\n\x04Type\x12\x0e\n\nREPLICATED\x10\x00\x12\x0b\n\x07MAXIMAL\x10\x01\x12\t\n\x05TUPLE\x10\x02\x12\t\n\x05OTHER\x10\x03\x12\n\n\x06MANUAL\x10\x04\x12\x0b\n\x07UNKNOWN\x10\x05\"\"\n\x0eShardGroupType\x12\x06\n\x02\x41S\x10\x00\x12\x08\n\x04LIKE\x10\x01\"#\n\x0cReplicaGroup\x12\x13\n\x0breplica_ids\x18\x01 \x03(\x03\".\n\x0cSourceTarget\x12\x0e\n\x06source\x18\x01 \x01(\x03\x12\x0e\n\x06target\x18\x02 \x01(\x03\"\x90\x01\n\x0fPrecisionConfig\x12\x39\n\x11operand_precision\x18\x01 \x03(\x0e\x32\x1e.xla.PrecisionConfig.Precision\"B\n\tPrecision\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\x08\n\x04HIGH\x10\x01\x12\x0b\n\x07HIGHEST\x10\x02\x12\x11\n\rPACKED_NIBBLE\x10\x03\":\n\x14ParameterReplication\x12\"\n\x1areplicated_at_leaf_buffers\x18\x01 \x03(\x08\"{\n\x16WhileLoopBackendConfig\x12\x44\n\x10known_trip_count\x18\x01 \x01(\x0b\x32*.xla.WhileLoopBackendConfig.KnownTripCount\x1a\x1b\n\x0eKnownTripCount\x12\t\n\x01n\x18\x01 \x01(\x03\"g\n\x15OutputOperandAliasing\x12\x1a\n\x12output_shape_index\x18\x01 \x03(\x03\x12\x15\n\roperand_index\x18\x02 \x01(\x03\x12\x1b\n\x13operand_shape_index\x18\x03 \x03(\x03*\xb7\x02\n\rPrimitiveType\x12\x1a\n\x16PRIMITIVE_TYPE_INVALID\x10\x00\x12\x08\n\x04PRED\x10\x01\x12\x06\n\x02S4\x10\x15\x12\x06\n\x02S8\x10\x02\x12\x07\n\x03S16\x10\x03\x12\x07\n\x03S32\x10\x04\x12\x07\n\x03S64\x10\x05\x12\x06\n\x02U4\x10\x16\x12\x06\n\x02U8\x10\x06\x12\x07\n\x03U16\x10\x07\x12\x07\n\x03U32\x10\x08\x12\x07\n\x03U64\x10\t\x12\x07\n\x03\x46\x31\x36\x10\n\x12\x07\n\x03\x46\x33\x32\x10\x0b\x12\x08\n\x04\x42\x46\x31\x36\x10\x10\x12\x07\n\x03\x46\x36\x34\x10\x0c\x12\n\n\x06\x46\x38\x45\x35M2\x10\x13\x12\x0c\n\x08\x46\x38\x45\x34M3FN\x10\x14\x12\x11\n\rF8E4M3B11FNUZ\x10\x17\x12\x0e\n\nF8E5M2FNUZ\x10\x18\x12\x0e\n\nF8E4M3FNUZ\x10\x19\x12\x07\n\x03\x43\x36\x34\x10\x0f\x12\x08\n\x04\x43\x31\x32\x38\x10\x12\x12\t\n\x05TUPLE\x10\r\x12\x0f\n\x0bOPAQUE_TYPE\x10\x0e\x12\t\n\x05TOKEN\x10\x11*^\n\x0c\x44imLevelType\x12\r\n\tDIM_DENSE\x10\x00\x12\x12\n\x0e\x44IM_COMPRESSED\x10\x01\x12\x11\n\rDIM_SINGLETON\x10\x02\x12\x18\n\x14\x44IM_LOOSE_COMPRESSED\x10\x03*=\n\x0bProfileType\x12\x0b\n\x07INVALID\x10\x00\x12\n\n\x06WINDOW\x10\x01\x12\x08\n\x04\x46LAG\x10\x02\x12\x0b\n\x07INTEGER\x10\x03*j\n\rProfileSource\x12!\n\x1dPROFILE_SOURCE_UNKNOWN_SOURCE\x10\x00\x12\x1b\n\x17PROFILE_SOURCE_EMBEDDED\x10\x01\x12\x19\n\x15PROFILE_SOURCE_REMOTE\x10\x02*\x85\x01\n\x10\x43ompilationEvent\x12#\n\x1f\x43OMPILATION_EVENT_UNKNOWN_EVENT\x10\x00\x12\'\n#COMPILATION_EVENT_FIRST_COMPILATION\x10\x01\x12#\n\x1f\x43OMPILATION_EVENT_RECOMPILATION\x10\x02*G\n\x0bPaddingType\x12\x13\n\x0fPADDING_INVALID\x10\x00\x12\x11\n\rPADDING_VALID\x10\x01\x12\x10\n\x0cPADDING_SAME\x10\x02*1\n\x07\x46\x66tType\x12\x07\n\x03\x46\x46T\x10\x00\x12\x08\n\x04IFFT\x10\x01\x12\x08\n\x04RFFT\x10\x02\x12\t\n\x05IRFFT\x10\x03*A\n\x0cSparsityType\x12\x14\n\x10SPARSITY_INVALID\x10\x00\x12\x1b\n\x17SPARSITY_STRUCTURED_N_M\x10\x01*F\n\x12RandomDistribution\x12\x0f\n\x0bRNG_INVALID\x10\x00\x12\x0f\n\x0bRNG_UNIFORM\x10\x01\x12\x0e\n\nRNG_NORMAL\x10\x02*E\n\x0fRandomAlgorithm\x12\x0f\n\x0bRNG_DEFAULT\x10\x00\x12\x11\n\rRNG_THREE_FRY\x10\x01\x12\x0e\n\nRNG_PHILOX\x10\x02\x42\x03\xf8\x01\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'xla.xla_data_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _OPMETADATA.fields_by_name['profile_type']._options = None
+  _OPMETADATA.fields_by_name['profile_type']._serialized_options = b'\030\001'
+  _FRONTENDATTRIBUTES_MAPENTRY._options = None
+  _FRONTENDATTRIBUTES_MAPENTRY._serialized_options = b'8\001'
+  _PRIMITIVETYPE._serialized_start=5709
+  _PRIMITIVETYPE._serialized_end=6020
+  _DIMLEVELTYPE._serialized_start=6022
+  _DIMLEVELTYPE._serialized_end=6116
+  _PROFILETYPE._serialized_start=6118
+  _PROFILETYPE._serialized_end=6179
+  _PROFILESOURCE._serialized_start=6181
+  _PROFILESOURCE._serialized_end=6287
+  _COMPILATIONEVENT._serialized_start=6290
+  _COMPILATIONEVENT._serialized_end=6423
+  _PADDINGTYPE._serialized_start=6425
+  _PADDINGTYPE._serialized_end=6496
+  _FFTTYPE._serialized_start=6498
+  _FFTTYPE._serialized_end=6547
+  _SPARSITYTYPE._serialized_start=6549
+  _SPARSITYTYPE._serialized_end=6614
+  _RANDOMDISTRIBUTION._serialized_start=6616
+  _RANDOMDISTRIBUTION._serialized_end=6686
+  _RANDOMALGORITHM._serialized_start=6688
+  _RANDOMALGORITHM._serialized_end=6757
+  _PADDINGCONFIG._serialized_start=28
+  _PADDINGCONFIG._serialized_end=211
+  _PADDINGCONFIG_PADDINGCONFIGDIMENSION._serialized_start=108
+  _PADDINGCONFIG_PADDINGCONFIGDIMENSION._serialized_end=211
+  _TILEPROTO._serialized_start=213
+  _TILEPROTO._serialized_end=244
+  _LAYOUTPROTO._serialized_start=247
+  _LAYOUTPROTO._serialized_end=771
+  _SHAPEPROTO._serialized_start=774
+  _SHAPEPROTO._serialized_end=963
+  _PROGRAMSHAPEPROTO._serialized_start=965
+  _PROGRAMSHAPEPROTO._serialized_end=1079
+  _COMPUTATIONSTATS._serialized_start=1081
+  _COMPUTATIONSTATS._serialized_end=1149
+  _OPMETADATA._serialized_start=1152
+  _OPMETADATA._serialized_end=1739
+  _OPMETADATA_PROFILEINFO._serialized_start=1560
+  _OPMETADATA_PROFILEINFO._serialized_end=1733
+  _EXECUTIONPROFILE._serialized_start=1742
+  _EXECUTIONPROFILE._serialized_end=1969
+  _EXECUTIONHANDLE._serialized_start=1971
+  _EXECUTIONHANDLE._serialized_end=2004
+  _GLOBALDATAHANDLE._serialized_start=2006
+  _GLOBALDATAHANDLE._serialized_end=2040
+  _DEVICEHANDLE._serialized_start=2042
+  _DEVICEHANDLE._serialized_end=2094
+  _CHANNELHANDLE._serialized_start=2097
+  _CHANNELHANDLE._serialized_end=2277
+  _CHANNELHANDLE_CHANNELTYPE._serialized_start=2176
+  _CHANNELHANDLE_CHANNELTYPE._serialized_end=2277
+  _DEVICEASSIGNMENTPROTO._serialized_start=2280
+  _DEVICEASSIGNMENTPROTO._serialized_end=2477
+  _DEVICEASSIGNMENTPROTO_COMPUTATIONDEVICE._serialized_start=2430
+  _DEVICEASSIGNMENTPROTO_COMPUTATIONDEVICE._serialized_end=2477
+  _LITERALPROTO._serialized_start=2480
+  _LITERALPROTO._serialized_end=2932
+  _WINDOWDIMENSION._serialized_start=2935
+  _WINDOWDIMENSION._serialized_end=3098
+  _WINDOW._serialized_start=3100
+  _WINDOW._serialized_end=3150
+  _GATHERDIMENSIONNUMBERS._serialized_start=3152
+  _GATHERDIMENSIONNUMBERS._serialized_end=3278
+  _SCATTERDIMENSIONNUMBERS._serialized_start=3281
+  _SCATTERDIMENSIONNUMBERS._serialized_end=3428
+  _CONVOLUTIONDIMENSIONNUMBERS._serialized_start=3431
+  _CONVOLUTIONDIMENSIONNUMBERS._serialized_end=3775
+  _DOTDIMENSIONNUMBERS._serialized_start=3778
+  _DOTDIMENSIONNUMBERS._serialized_end=3931
+  _SPARSITYDESCRIPTOR._serialized_start=3933
+  _SPARSITYDESCRIPTOR._serialized_end=4042
+  _TRIANGULARSOLVEOPTIONS._serialized_start=4045
+  _TRIANGULARSOLVEOPTIONS._serialized_end=4268
+  _TRIANGULARSOLVEOPTIONS_TRANSPOSE._serialized_start=4188
+  _TRIANGULARSOLVEOPTIONS_TRANSPOSE._serialized_end=4268
+  _CHOLESKYOPTIONS._serialized_start=4270
+  _CHOLESKYOPTIONS._serialized_end=4302
+  _SORTOPTIONS._serialized_start=4304
+  _SORTOPTIONS._serialized_end=4337
+  _FRONTENDATTRIBUTES._serialized_start=4339
+  _FRONTENDATTRIBUTES._serialized_end=4450
+  _FRONTENDATTRIBUTES_MAPENTRY._serialized_start=4408
+  _FRONTENDATTRIBUTES_MAPENTRY._serialized_end=4450
+  _STATISTIC._serialized_start=4452
+  _STATISTIC._serialized_end=4500
+  _STATISTICSVIZ._serialized_start=4502
+  _STATISTICSVIZ._serialized_end=4586
+  _OPSHARDING._serialized_start=4589
+  _OPSHARDING._serialized_end=5184
+  _OPSHARDING_TYPE._serialized_start=5066
+  _OPSHARDING_TYPE._serialized_end=5148
+  _OPSHARDING_SHARDGROUPTYPE._serialized_start=5150
+  _OPSHARDING_SHARDGROUPTYPE._serialized_end=5184
+  _REPLICAGROUP._serialized_start=5186
+  _REPLICAGROUP._serialized_end=5221
+  _SOURCETARGET._serialized_start=5223
+  _SOURCETARGET._serialized_end=5269
+  _PRECISIONCONFIG._serialized_start=5272
+  _PRECISIONCONFIG._serialized_end=5416
+  _PRECISIONCONFIG_PRECISION._serialized_start=5350
+  _PRECISIONCONFIG_PRECISION._serialized_end=5416
+  _PARAMETERREPLICATION._serialized_start=5418
+  _PARAMETERREPLICATION._serialized_end=5476
+  _WHILELOOPBACKENDCONFIG._serialized_start=5478
+  _WHILELOOPBACKENDCONFIG._serialized_end=5601
+  _WHILELOOPBACKENDCONFIG_KNOWNTRIPCOUNT._serialized_start=5574
+  _WHILELOOPBACKENDCONFIG_KNOWNTRIPCOUNT._serialized_end=5601
+  _OUTPUTOPERANDALIASING._serialized_start=5603
+  _OUTPUTOPERANDALIASING._serialized_end=5706
+# @@protoc_insertion_point(module_scope)