Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/tensorflow/include/external/png/LICENSE

@@ -0,0 +1,134 @@
+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
+=========================================
+
+PNG Reference Library License version 2
+---------------------------------------
+
+ * Copyright (c) 1995-2022 The PNG Reference Library Authors.
+ * Copyright (c) 2018-2022 Cosmin Truta.
+ * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
+ * Copyright (c) 1996-1997 Andreas Dilger.
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+
+The software is supplied "as is", without warranty of any kind,
+express or implied, including, without limitation, the warranties
+of merchantability, fitness for a particular purpose, title, and
+non-infringement.  In no event shall the Copyright owners, or
+anyone distributing the software, be liable for any damages or
+other liability, whether in contract, tort or otherwise, arising
+from, out of, or in connection with the software, or the use or
+other dealings in the software, even if advised of the possibility
+of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute
+this software, or portions hereof, for any purpose, without fee,
+subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you
+    must not claim that you wrote the original software.  If you
+    use this software in a product, an acknowledgment in the product
+    documentation would be appreciated, but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must
+    not be misrepresented as being the original software.
+
+ 3. This Copyright notice may not be removed or altered from any
+    source or altered source distribution.
+
+
+PNG Reference Library License version 1 (for libpng 0.5 through 1.6.35)
+-----------------------------------------------------------------------
+
+libpng versions 1.0.7, July 1, 2000, through 1.6.35, July 15, 2018 are
+Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson, are
+derived from libpng-1.0.6, and are distributed according to the same
+disclaimer and license as libpng-1.0.6 with the following individuals
+added to the list of Contributing Authors:
+
+    Simon-Pierre Cadieux
+    Eric S. Raymond
+    Mans Rullgard
+    Cosmin Truta
+    Gilles Vollant
+    James Yu
+    Mandar Sahastrabuddhe
+    Google Inc.
+    Vadim Barkov
+
+and with the following additions to the disclaimer:
+
+    There is no warranty against interference with your enjoyment of
+    the library or against infringement.  There is no warranty that our
+    efforts or the library will fulfill any of your particular purposes
+    or needs.  This library is provided with all faults, and the entire
+    risk of satisfactory quality, performance, accuracy, and effort is
+    with the user.
+
+Some files in the "contrib" directory and some configure-generated
+files that are distributed with libpng have other copyright owners, and
+are released under other open source licenses.
+
+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
+libpng-0.96, and are distributed according to the same disclaimer and
+license as libpng-0.96, with the following individuals added to the
+list of Contributing Authors:
+
+    Tom Lane
+    Glenn Randers-Pehrson
+    Willem van Schaik
+
+libpng versions 0.89, June 1996, through 0.96, May 1997, are
+Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
+and are distributed according to the same disclaimer and license as
+libpng-0.88, with the following individuals added to the list of
+Contributing Authors:
+
+    John Bowler
+    Kevin Bracey
+    Sam Bushell
+    Magnus Holmgren
+    Greg Roelofs
+    Tom Tanner
+
+Some files in the "scripts" directory have other copyright owners,
+but are released under this license.
+
+libpng versions 0.5, May 1995, through 0.88, January 1996, are
+Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+
+For the purposes of this copyright and license, "Contributing Authors"
+is defined as the following set of individuals:
+
+    Andreas Dilger
+    Dave Martindale
+    Guy Eric Schalnat
+    Paul Schmidt
+    Tim Wegner
+
+The PNG Reference Library is supplied "AS IS".  The Contributing
+Authors and Group 42, Inc. disclaim all warranties, expressed or
+implied, including, without limitation, the warranties of
+merchantability and of fitness for any purpose.  The Contributing
+Authors and Group 42, Inc. assume no liability for direct, indirect,
+incidental, special, exemplary, or consequential damages, which may
+result from the use of the PNG Reference Library, even if advised of
+the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+ 1. The origin of this source code must not be misrepresented.
+
+ 2. Altered versions must be plainly marked as such and must not
+    be misrepresented as being the original source.
+
+ 3. This Copyright notice may not be removed or altered from any
+    source or altered source distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit,
+without fee, and encourage the use of this source code as a component
+to supporting the PNG file format in commercial products.  If you use
+this source code in a product, acknowledgment is not required but would
+be appreciated.

videochat2/lib/python3.10/site-packages/tensorflow/include/external/png/pngdebug.h

@@ -0,0 +1,153 @@
+
+/* pngdebug.h - Debugging macros for libpng, also used in pngtest.c
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2013 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* Define PNG_DEBUG at compile time for debugging information.  Higher
+ * numbers for PNG_DEBUG mean more debugging information.  This has
+ * only been added since version 0.95 so it is not implemented throughout
+ * libpng yet, but more support will be added as needed.
+ *
+ * png_debug[1-2]?(level, message ,arg{0-2})
+ *   Expands to a statement (either a simple expression or a compound
+ *   do..while(0) statement) that outputs a message with parameter
+ *   substitution if PNG_DEBUG is defined to 2 or more.  If PNG_DEBUG
+ *   is undefined, 0 or 1 every png_debug expands to a simple expression
+ *   (actually ((void)0)).
+ *
+ *   level: level of detail of message, starting at 0.  A level 'n'
+ *          message is preceded by 'n' 3-space indentations (not implemented
+ *          on Microsoft compilers unless PNG_DEBUG_FILE is also
+ *          defined, to allow debug DLL compilation with no standard IO).
+ *   message: a printf(3) style text string.  A trailing '\n' is added
+ *            to the message.
+ *   arg: 0 to 2 arguments for printf(3) style substitution in message.
+ */
+#ifndef PNGDEBUG_H
+#define PNGDEBUG_H
+/* These settings control the formatting of messages in png.c and pngerror.c */
+/* Moved to pngdebug.h at 1.5.0 */
+#  ifndef PNG_LITERAL_SHARP
+#    define PNG_LITERAL_SHARP 0x23
+#  endif
+#  ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET
+#    define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b
+#  endif
+#  ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET
+#    define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d
+#  endif
+#  ifndef PNG_STRING_NEWLINE
+#    define PNG_STRING_NEWLINE "\n"
+#  endif
+
+#ifdef PNG_DEBUG
+#  if (PNG_DEBUG > 0)
+#    if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)
+#      include <crtdbg.h>
+#      if (PNG_DEBUG > 1)
+#        ifndef _DEBUG
+#          define _DEBUG
+#        endif
+#        ifndef png_debug
+#          define png_debug(l,m)  _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE)
+#        endif
+#        ifndef png_debug1
+#          define png_debug1(l,m,p1)  _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1)
+#        endif
+#        ifndef png_debug2
+#          define png_debug2(l,m,p1,p2) \
+             _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2)
+#        endif
+#      endif
+#    else /* PNG_DEBUG_FILE || !_MSC_VER */
+#      ifndef PNG_STDIO_SUPPORTED
+#        include <stdio.h> /* not included yet */
+#      endif
+#      ifndef PNG_DEBUG_FILE
+#        define PNG_DEBUG_FILE stderr
+#      endif /* PNG_DEBUG_FILE */
+
+#      if (PNG_DEBUG > 1)
+#        ifdef __STDC__
+#          ifndef png_debug
+#            define png_debug(l,m) \
+       do { \
+       int num_tabs=l; \
+       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
+         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : "")))); \
+       } while (0)
+#          endif
+#          ifndef png_debug1
+#            define png_debug1(l,m,p1) \
+       do { \
+       int num_tabs=l; \
+       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
+         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : ""))),p1); \
+       } while (0)
+#          endif
+#          ifndef png_debug2
+#            define png_debug2(l,m,p1,p2) \
+       do { \
+       int num_tabs=l; \
+       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
+         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : ""))),p1,p2);\
+       } while (0)
+#          endif
+#        else /* __STDC __ */
+#          ifndef png_debug
+#            define png_debug(l,m) \
+       do { \
+       int num_tabs=l; \
+       char format[256]; \
+       snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
+         m,PNG_STRING_NEWLINE); \
+       fprintf(PNG_DEBUG_FILE,format); \
+       } while (0)
+#          endif
+#          ifndef png_debug1
+#            define png_debug1(l,m,p1) \
+       do { \
+       int num_tabs=l; \
+       char format[256]; \
+       snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
+         m,PNG_STRING_NEWLINE); \
+       fprintf(PNG_DEBUG_FILE,format,p1); \
+       } while (0)
+#          endif
+#          ifndef png_debug2
+#            define png_debug2(l,m,p1,p2) \
+       do { \
+       int num_tabs=l; \
+       char format[256]; \
+       snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
+         m,PNG_STRING_NEWLINE); \
+       fprintf(PNG_DEBUG_FILE,format,p1,p2); \
+       } while (0)
+#          endif
+#        endif /* __STDC __ */
+#      endif /* (PNG_DEBUG > 1) */
+
+#    endif /* _MSC_VER */
+#  endif /* (PNG_DEBUG > 0) */
+#endif /* PNG_DEBUG */
+#ifndef png_debug
+#  define png_debug(l, m) ((void)0)
+#endif
+#ifndef png_debug1
+#  define png_debug1(l, m, p1) ((void)0)
+#endif
+#ifndef png_debug2
+#  define png_debug2(l, m, p1, p2) ((void)0)
+#endif
+#endif /* PNGDEBUG_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/png/pnginfo.h

@@ -0,0 +1,267 @@
+
+/* pnginfo.h - header file for PNG reference library
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2013,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+ /* png_info is a structure that holds the information in a PNG file so
+ * that the application can find out the characteristics of the image.
+ * If you are reading the file, this structure will tell you what is
+ * in the PNG file.  If you are writing the file, fill in the information
+ * you want to put into the PNG file, using png_set_*() functions, then
+ * call png_write_info().
+ *
+ * The names chosen should be very close to the PNG specification, so
+ * consult that document for information about the meaning of each field.
+ *
+ * With libpng < 0.95, it was only possible to directly set and read the
+ * the values in the png_info_struct, which meant that the contents and
+ * order of the values had to remain fixed.  With libpng 0.95 and later,
+ * however, there are now functions that abstract the contents of
+ * png_info_struct from the application, so this makes it easier to use
+ * libpng with dynamic libraries, and even makes it possible to use
+ * libraries that don't have all of the libpng ancillary chunk-handing
+ * functionality.  In libpng-1.5.0 this was moved into a separate private
+ * file that is not visible to applications.
+ *
+ * The following members may have allocated storage attached that should be
+ * cleaned up before the structure is discarded: palette, trans, text,
+ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,
+ * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these
+ * are automatically freed when the info structure is deallocated, if they were
+ * allocated internally by libpng.  This behavior can be changed by means
+ * of the png_data_freer() function.
+ *
+ * More allocation details: all the chunk-reading functions that
+ * change these members go through the corresponding png_set_*
+ * functions.  A function to clear these members is available: see
+ * png_free_data().  The png_set_* functions do not depend on being
+ * able to point info structure members to any of the storage they are
+ * passed (they make their own copies), EXCEPT that the png_set_text
+ * functions use the same storage passed to them in the text_ptr or
+ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns
+ * functions do not make their own copies.
+ */
+#ifndef PNGINFO_H
+#define PNGINFO_H
+
+struct png_info_def
+{
+   /* The following are necessary for every PNG file */
+   png_uint_32 width;       /* width of image in pixels (from IHDR) */
+   png_uint_32 height;      /* height of image in pixels (from IHDR) */
+   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */
+   size_t rowbytes;         /* bytes needed to hold an untransformed row */
+   png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */
+   png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */
+   png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */
+   png_byte bit_depth;      /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */
+   png_byte color_type;     /* see PNG_COLOR_TYPE_ below (from IHDR) */
+   /* The following three should have been named *_method not *_type */
+   png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */
+   png_byte filter_type;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */
+   png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
+
+   /* The following are set by png_set_IHDR, called from the application on
+    * write, but the are never actually used by the write code.
+    */
+   png_byte channels;       /* number of data channels per pixel (1, 2, 3, 4) */
+   png_byte pixel_depth;    /* number of bits per pixel */
+   png_byte spare_byte;     /* to align the data, and for future use */
+
+#ifdef PNG_READ_SUPPORTED
+   /* This is never set during write */
+   png_byte signature[8];   /* magic bytes read by libpng from start of file */
+#endif
+
+   /* The rest of the data is optional.  If you are reading, check the
+    * valid field to see if the information in these are valid.  If you
+    * are writing, set the valid field to those chunks you want written,
+    * and initialize the appropriate fields below.
+    */
+
+#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
+   /* png_colorspace only contains 'flags' if neither GAMMA or COLORSPACE are
+    * defined.  When COLORSPACE is switched on all the colorspace-defining
+    * chunks should be enabled, when GAMMA is switched on all the gamma-defining
+    * chunks should be enabled.  If this is not done it becomes possible to read
+    * inconsistent PNG files and assign a probably incorrect interpretation to
+    * the information.  (In other words, by carefully choosing which chunks to
+    * recognize the system configuration can select an interpretation for PNG
+    * files containing ambiguous data and this will result in inconsistent
+    * behavior between different libpng builds!)
+    */
+   png_colorspace colorspace;
+#endif
+
+#ifdef PNG_iCCP_SUPPORTED
+   /* iCCP chunk data. */
+   png_charp iccp_name;     /* profile name */
+   png_bytep iccp_profile;  /* International Color Consortium profile data */
+   png_uint_32 iccp_proflen;  /* ICC profile data length */
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED
+   /* The tEXt, and zTXt chunks contain human-readable textual data in
+    * uncompressed, compressed, and optionally compressed forms, respectively.
+    * The data in "text" is an array of pointers to uncompressed,
+    * null-terminated C strings. Each chunk has a keyword that describes the
+    * textual data contained in that chunk.  Keywords are not required to be
+    * unique, and the text string may be empty.  Any number of text chunks may
+    * be in an image.
+    */
+   int num_text; /* number of comments read or comments to write */
+   int max_text; /* current size of text array */
+   png_textp text; /* array of comments read or comments to write */
+#endif /* TEXT */
+
+#ifdef PNG_tIME_SUPPORTED
+   /* The tIME chunk holds the last time the displayed image data was
+    * modified.  See the png_time struct for the contents of this struct.
+    */
+   png_time mod_time;
+#endif
+
+#ifdef PNG_sBIT_SUPPORTED
+   /* The sBIT chunk specifies the number of significant high-order bits
+    * in the pixel data.  Values are in the range [1, bit_depth], and are
+    * only specified for the channels in the pixel data.  The contents of
+    * the low-order bits is not specified.  Data is valid if
+    * (valid & PNG_INFO_sBIT) is non-zero.
+    */
+   png_color_8 sig_bit; /* significant bits in color channels */
+#endif
+
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \
+defined(PNG_READ_BACKGROUND_SUPPORTED)
+   /* The tRNS chunk supplies transparency data for paletted images and
+    * other image types that don't need a full alpha channel.  There are
+    * "num_trans" transparency values for a paletted image, stored in the
+    * same order as the palette colors, starting from index 0.  Values
+    * for the data are in the range [0, 255], ranging from fully transparent
+    * to fully opaque, respectively.  For non-paletted images, there is a
+    * single color specified that should be treated as fully transparent.
+    * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.
+    */
+   png_bytep trans_alpha;    /* alpha values for paletted image */
+   png_color_16 trans_color; /* transparent color for non-palette image */
+#endif
+
+#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
+   /* The bKGD chunk gives the suggested image background color if the
+    * display program does not have its own background color and the image
+    * is needs to composited onto a background before display.  The colors
+    * in "background" are normally in the same color space/depth as the
+    * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.
+    */
+   png_color_16 background;
+#endif
+
+#ifdef PNG_oFFs_SUPPORTED
+   /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards
+    * and downwards from the top-left corner of the display, page, or other
+    * application-specific co-ordinate space.  See the PNG_OFFSET_ defines
+    * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.
+    */
+   png_int_32 x_offset; /* x offset on page */
+   png_int_32 y_offset; /* y offset on page */
+   png_byte offset_unit_type; /* offset units type */
+#endif
+
+#ifdef PNG_pHYs_SUPPORTED
+   /* The pHYs chunk gives the physical pixel density of the image for
+    * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_
+    * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.
+    */
+   png_uint_32 x_pixels_per_unit; /* horizontal pixel density */
+   png_uint_32 y_pixels_per_unit; /* vertical pixel density */
+   png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */
+#endif
+
+#ifdef PNG_eXIf_SUPPORTED
+   int num_exif;  /* Added at libpng-1.6.31 */
+   png_bytep exif;
+# ifdef PNG_READ_eXIf_SUPPORTED
+   png_bytep eXIf_buf;  /* Added at libpng-1.6.32 */
+# endif
+#endif
+
+#ifdef PNG_hIST_SUPPORTED
+   /* The hIST chunk contains the relative frequency or importance of the
+    * various palette entries, so that a viewer can intelligently select a
+    * reduced-color palette, if required.  Data is an array of "num_palette"
+    * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)
+    * is non-zero.
+    */
+   png_uint_16p hist;
+#endif
+
+#ifdef PNG_pCAL_SUPPORTED
+   /* The pCAL chunk describes a transformation between the stored pixel
+    * values and original physical data values used to create the image.
+    * The integer range [0, 2^bit_depth - 1] maps to the floating-point
+    * range given by [pcal_X0, pcal_X1], and are further transformed by a
+    * (possibly non-linear) transformation function given by "pcal_type"
+    * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_
+    * defines below, and the PNG-Group's PNG extensions document for a
+    * complete description of the transformations and how they should be
+    * implemented, and for a description of the ASCII parameter strings.
+    * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.
+    */
+   png_charp pcal_purpose;  /* pCAL chunk description string */
+   png_int_32 pcal_X0;      /* minimum value */
+   png_int_32 pcal_X1;      /* maximum value */
+   png_charp pcal_units;    /* Latin-1 string giving physical units */
+   png_charpp pcal_params;  /* ASCII strings containing parameter values */
+   png_byte pcal_type;      /* equation type (see PNG_EQUATION_ below) */
+   png_byte pcal_nparams;   /* number of parameters given in pcal_params */
+#endif
+
+/* New members added in libpng-1.0.6 */
+   png_uint_32 free_me;     /* flags items libpng is responsible for freeing */
+
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+   /* Storage for unknown chunks that the library doesn't recognize. */
+   png_unknown_chunkp unknown_chunks;
+
+   /* The type of this field is limited by the type of
+    * png_struct::user_chunk_cache_max, else overflow can occur.
+    */
+   int                unknown_chunks_num;
+#endif
+
+#ifdef PNG_sPLT_SUPPORTED
+   /* Data on sPLT chunks (there may be more than one). */
+   png_sPLT_tp splt_palettes;
+   int         splt_palettes_num; /* Match type returned by png_get API */
+#endif
+
+#ifdef PNG_sCAL_SUPPORTED
+   /* The sCAL chunk describes the actual physical dimensions of the
+    * subject matter of the graphic.  The chunk contains a unit specification
+    * a byte value, and two ASCII strings representing floating-point
+    * values.  The values are width and height corresponding to one pixel
+    * in the image.  Data values are valid if (valid & PNG_INFO_sCAL) is
+    * non-zero.
+    */
+   png_byte scal_unit;         /* unit of physical scale */
+   png_charp scal_s_width;     /* string containing height */
+   png_charp scal_s_height;    /* string containing width */
+#endif
+
+#ifdef PNG_INFO_IMAGE_SUPPORTED
+   /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS)
+      non-zero */
+   /* Data valid if (valid & PNG_INFO_IDAT) non-zero */
+   png_bytepp row_pointers;        /* the image bits */
+#endif
+
+};
+#endif /* PNGINFO_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/png/pngpriv.h

@@ -0,0 +1,2143 @@
+
+/* pngpriv.h - private declarations for use inside libpng
+ *
+ * Copyright (c) 2018-2022 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+/* The symbols declared in this file (including the functions declared
+ * as extern) are PRIVATE.  They are not part of the libpng public
+ * interface, and are not recommended for use by regular applications.
+ * Some of them may become public in the future; others may stay private,
+ * change in an incompatible way, or even disappear.
+ * Although the libpng users are not forbidden to include this header,
+ * they should be well aware of the issues that may arise from doing so.
+ */
+
+#ifndef PNGPRIV_H
+#define PNGPRIV_H
+
+/* Feature Test Macros.  The following are defined here to ensure that correctly
+ * implemented libraries reveal the APIs libpng needs to build and hide those
+ * that are not needed and potentially damaging to the compilation.
+ *
+ * Feature Test Macros must be defined before any system header is included (see
+ * POSIX 1003.1 2.8.2 "POSIX Symbols."
+ *
+ * These macros only have an effect if the operating system supports either
+ * POSIX 1003.1 or C99, or both.  On other operating systems (particularly
+ * Windows/Visual Studio) there is no effect; the OS specific tests below are
+ * still required (as of 2011-05-02.)
+ */
+#ifndef _POSIX_SOURCE
+# define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */
+#endif
+
+#ifndef PNG_VERSION_INFO_ONLY
+/* Standard library headers not required by png.h: */
+#  include <stdlib.h>
+#  include <string.h>
+#endif
+
+#define PNGLIB_BUILD /*libpng is being built, not used*/
+
+/* If HAVE_CONFIG_H is defined during the build then the build system must
+ * provide an appropriate "config.h" file on the include path.  The header file
+ * must provide definitions as required below (search for "HAVE_CONFIG_H");
+ * see configure.ac for more details of the requirements.  The macro
+ * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on
+ * 'configure'; define this macro to prevent the configure build including the
+ * configure generated config.h.  Libpng is expected to compile without *any*
+ * special build system support on a reasonably ANSI-C compliant system.
+ */
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
+#  include <config.h>
+
+   /* Pick up the definition of 'restrict' from config.h if it was read: */
+#  define PNG_RESTRICT restrict
+#endif
+
+/* To support symbol prefixing it is necessary to know *before* including png.h
+ * whether the fixed point (and maybe other) APIs are exported, because if they
+ * are not internal definitions may be required.  This is handled below just
+ * before png.h is included, but load the configuration now if it is available.
+ */
+#ifndef PNGLCONF_H
+#  include "pnglibconf.h"
+#endif
+
+/* Local renames may change non-exported API functions from png.h */
+#if defined(PNG_PREFIX) && !defined(PNGPREFIX_H)
+#  include "pngprefix.h"
+#endif
+
+#ifdef PNG_USER_CONFIG
+#  include "pngusr.h"
+   /* These should have been defined in pngusr.h */
+#  ifndef PNG_USER_PRIVATEBUILD
+#    define PNG_USER_PRIVATEBUILD "Custom libpng build"
+#  endif
+#  ifndef PNG_USER_DLLFNAME_POSTFIX
+#    define PNG_USER_DLLFNAME_POSTFIX "Cb"
+#  endif
+#endif
+
+/* Compile time options.
+ * =====================
+ * In a multi-arch build the compiler may compile the code several times for the
+ * same object module, producing different binaries for different architectures.
+ * When this happens configure-time setting of the target host options cannot be
+ * done and this interferes with the handling of the ARM NEON optimizations, and
+ * possibly other similar optimizations.  Put additional tests here; in general
+ * this is needed when the same option can be changed at both compile time and
+ * run time depending on the target OS (i.e. iOS vs Android.)
+ *
+ * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because
+ * this is not possible with certain compilers (Oracle SUN OS CC), as a result
+ * it is necessary to ensure that all extern functions that *might* be used
+ * regardless of $(CFLAGS) get declared in this file.  The test on __ARM_NEON__
+ * below is one example of this behavior because it is controlled by the
+ * presence or not of -mfpu=neon on the GCC command line, it is possible to do
+ * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely
+ * do this.
+ */
+#ifndef PNG_ARM_NEON_OPT
+   /* ARM NEON optimizations are being controlled by the compiler settings,
+    * typically the target FPU.  If the FPU has been set to NEON (-mfpu=neon
+    * with GCC) then the compiler will define __ARM_NEON__ and we can rely
+    * unconditionally on NEON instructions not crashing, otherwise we must
+    * disable use of NEON instructions.
+    *
+    * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they
+    * can only be turned on automatically if that is supported too.  If
+    * PNG_ARM_NEON_OPT is set in CPPFLAGS (to >0) then arm/arm_init.c will fail
+    * to compile with an appropriate #error if ALIGNED_MEMORY has been turned
+    * off.
+    *
+    * Note that gcc-4.9 defines __ARM_NEON instead of the deprecated
+    * __ARM_NEON__, so we check both variants.
+    *
+    * To disable ARM_NEON optimizations entirely, and skip compiling the
+    * associated assembler code, pass --enable-arm-neon=no to configure
+    * or put -DPNG_ARM_NEON_OPT=0 in CPPFLAGS.
+    */
+#  if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && \
+   defined(PNG_ALIGNED_MEMORY_SUPPORTED)
+#     define PNG_ARM_NEON_OPT 2
+#  else
+#     define PNG_ARM_NEON_OPT 0
+#  endif
+#endif
+
+#if PNG_ARM_NEON_OPT > 0
+   /* NEON optimizations are to be at least considered by libpng, so enable the
+    * callbacks to do this.
+    */
+#  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon
+
+   /* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used
+    * if possible - if __ARM_NEON__ is set and the compiler version is not known
+    * to be broken.  This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can
+    * be:
+    *
+    *    1  The intrinsics code (the default with __ARM_NEON__)
+    *    2  The hand coded assembler (the default without __ARM_NEON__)
+    *
+    * It is possible to set PNG_ARM_NEON_IMPLEMENTATION in CPPFLAGS, however
+    * this is *NOT* supported and may cease to work even after a minor revision
+    * to libpng.  It *is* valid to do this for testing purposes, e.g. speed
+    * testing or a new compiler, but the results should be communicated to the
+    * libpng implementation list for incorporation in the next minor release.
+    */
+#  ifndef PNG_ARM_NEON_IMPLEMENTATION
+#     if defined(__ARM_NEON__) || defined(__ARM_NEON)
+#        if defined(__clang__)
+            /* At present it is unknown by the libpng developers which versions
+             * of clang support the intrinsics, however some or perhaps all
+             * versions do not work with the assembler so this may be
+             * irrelevant, so just use the default (do nothing here.)
+             */
+#        elif defined(__GNUC__)
+            /* GCC 4.5.4 NEON support is known to be broken.  4.6.3 is known to
+             * work, so if this *is* GCC, or G++, look for a version >4.5
+             */
+#           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)
+#              define PNG_ARM_NEON_IMPLEMENTATION 2
+#           endif /* no GNUC support */
+#        endif /* __GNUC__ */
+#     else /* !defined __ARM_NEON__ */
+         /* The 'intrinsics' code simply won't compile without this -mfpu=neon:
+          */
+#        if !defined(__aarch64__) && !defined(_M_ARM64)
+            /* The assembler code currently does not work on ARM64 */
+#          define PNG_ARM_NEON_IMPLEMENTATION 2
+#        endif /* __aarch64__ */
+#     endif /* __ARM_NEON__ */
+#  endif /* !PNG_ARM_NEON_IMPLEMENTATION */
+
+#  ifndef PNG_ARM_NEON_IMPLEMENTATION
+      /* Use the intrinsics code by default. */
+#     define PNG_ARM_NEON_IMPLEMENTATION 1
+#  endif
+#else /* PNG_ARM_NEON_OPT == 0 */
+#     define PNG_ARM_NEON_IMPLEMENTATION 0
+#endif /* PNG_ARM_NEON_OPT > 0 */
+
+#ifndef PNG_MIPS_MSA_OPT
+#  if defined(__mips_msa) && (__mips_isa_rev >= 5) && defined(PNG_ALIGNED_MEMORY_SUPPORTED)
+#     define PNG_MIPS_MSA_OPT 2
+#  else
+#     define PNG_MIPS_MSA_OPT 0
+#  endif
+#endif
+
+#ifndef PNG_POWERPC_VSX_OPT
+#  if defined(__PPC64__) && defined(__ALTIVEC__) && defined(__VSX__)
+#     define PNG_POWERPC_VSX_OPT 2
+#  else
+#     define PNG_POWERPC_VSX_OPT 0
+#  endif
+#endif
+
+#ifndef PNG_INTEL_SSE_OPT
+#   ifdef PNG_INTEL_SSE
+      /* Only check for SSE if the build configuration has been modified to
+       * enable SSE optimizations.  This means that these optimizations will
+       * be off by default.  See contrib/intel for more details.
+       */
+#     if defined(__SSE4_1__) || defined(__AVX__) || defined(__SSSE3__) || \
+       defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
+       (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
+#         define PNG_INTEL_SSE_OPT 1
+#      else
+#         define PNG_INTEL_SSE_OPT 0
+#      endif
+#   else
+#      define PNG_INTEL_SSE_OPT 0
+#   endif
+#endif
+
+#if PNG_INTEL_SSE_OPT > 0
+#   ifndef PNG_INTEL_SSE_IMPLEMENTATION
+#      if defined(__SSE4_1__) || defined(__AVX__)
+          /* We are not actually using AVX, but checking for AVX is the best
+             way we can detect SSE4.1 and SSSE3 on MSVC.
+          */
+#         define PNG_INTEL_SSE_IMPLEMENTATION 3
+#      elif defined(__SSSE3__)
+#         define PNG_INTEL_SSE_IMPLEMENTATION 2
+#      elif defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
+       (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
+#         define PNG_INTEL_SSE_IMPLEMENTATION 1
+#      else
+#         define PNG_INTEL_SSE_IMPLEMENTATION 0
+#      endif
+#   endif
+
+#   if PNG_INTEL_SSE_IMPLEMENTATION > 0
+#      define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_sse2
+#   endif
+#else
+#   define PNG_INTEL_SSE_IMPLEMENTATION 0
+#endif
+
+#if PNG_MIPS_MSA_OPT > 0
+#  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_msa
+#  ifndef PNG_MIPS_MSA_IMPLEMENTATION
+#     if defined(__mips_msa)
+#        if defined(__clang__)
+#        elif defined(__GNUC__)
+#           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
+#              define PNG_MIPS_MSA_IMPLEMENTATION 2
+#           endif /* no GNUC support */
+#        endif /* __GNUC__ */
+#     else /* !defined __mips_msa */
+#        define PNG_MIPS_MSA_IMPLEMENTATION 2
+#     endif /* __mips_msa */
+#  endif /* !PNG_MIPS_MSA_IMPLEMENTATION */
+
+#  ifndef PNG_MIPS_MSA_IMPLEMENTATION
+#     define PNG_MIPS_MSA_IMPLEMENTATION 1
+#  endif
+#else
+#  define PNG_MIPS_MSA_IMPLEMENTATION 0
+#endif /* PNG_MIPS_MSA_OPT > 0 */
+
+#if PNG_POWERPC_VSX_OPT > 0
+#  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_vsx
+#  define PNG_POWERPC_VSX_IMPLEMENTATION 1
+#else
+#  define PNG_POWERPC_VSX_IMPLEMENTATION 0
+#endif
+
+
+/* Is this a build of a DLL where compilation of the object modules requires
+ * different preprocessor settings to those required for a simple library?  If
+ * so PNG_BUILD_DLL must be set.
+ *
+ * If libpng is used inside a DLL but that DLL does not export the libpng APIs
+ * PNG_BUILD_DLL must not be set.  To avoid the code below kicking in build a
+ * static library of libpng then link the DLL against that.
+ */
+#ifndef PNG_BUILD_DLL
+#  ifdef DLL_EXPORT
+      /* This is set by libtool when files are compiled for a DLL; libtool
+       * always compiles twice, even on systems where it isn't necessary.  Set
+       * PNG_BUILD_DLL in case it is necessary:
+       */
+#     define PNG_BUILD_DLL
+#  else
+#     ifdef _WINDLL
+         /* This is set by the Microsoft Visual Studio IDE in projects that
+          * build a DLL.  It can't easily be removed from those projects (it
+          * isn't visible in the Visual Studio UI) so it is a fairly reliable
+          * indication that PNG_IMPEXP needs to be set to the DLL export
+          * attributes.
+          */
+#        define PNG_BUILD_DLL
+#     else
+#        ifdef __DLL__
+            /* This is set by the Borland C system when compiling for a DLL
+             * (as above.)
+             */
+#           define PNG_BUILD_DLL
+#        else
+            /* Add additional compiler cases here. */
+#        endif
+#     endif
+#  endif
+#endif /* Setting PNG_BUILD_DLL if required */
+
+/* See pngconf.h for more details: the builder of the library may set this on
+ * the command line to the right thing for the specific compilation system or it
+ * may be automagically set above (at present we know of no system where it does
+ * need to be set on the command line.)
+ *
+ * PNG_IMPEXP must be set here when building the library to prevent pngconf.h
+ * setting it to the "import" setting for a DLL build.
+ */
+#ifndef PNG_IMPEXP
+#  ifdef PNG_BUILD_DLL
+#     define PNG_IMPEXP PNG_DLL_EXPORT
+#  else
+      /* Not building a DLL, or the DLL doesn't require specific export
+       * definitions.
+       */
+#     define PNG_IMPEXP
+#  endif
+#endif
+
+/* No warnings for private or deprecated functions in the build: */
+#ifndef PNG_DEPRECATED
+#  define PNG_DEPRECATED
+#endif
+#ifndef PNG_PRIVATE
+#  define PNG_PRIVATE
+#endif
+
+/* Symbol preprocessing support.
+ *
+ * To enable listing global, but internal, symbols the following macros should
+ * always be used to declare an extern data or function object in this file.
+ */
+#ifndef PNG_INTERNAL_DATA
+#  define PNG_INTERNAL_DATA(type, name, array) PNG_LINKAGE_DATA type name array
+#endif
+
+#ifndef PNG_INTERNAL_FUNCTION
+#  define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
+      PNG_LINKAGE_FUNCTION PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
+#endif
+
+#ifndef PNG_INTERNAL_CALLBACK
+#  define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\
+      PNG_LINKAGE_CALLBACK PNG_FUNCTION(type, (PNGCBAPI name), args,\
+         PNG_EMPTY attributes)
+#endif
+
+/* If floating or fixed point APIs are disabled they may still be compiled
+ * internally.  To handle this make sure they are declared as the appropriate
+ * internal extern function (otherwise the symbol prefixing stuff won't work and
+ * the functions will be used without definitions.)
+ *
+ * NOTE: although all the API functions are declared here they are not all
+ * actually built!  Because the declarations are still made it is necessary to
+ * fake out types that they depend on.
+ */
+#ifndef PNG_FP_EXPORT
+#  ifndef PNG_FLOATING_POINT_SUPPORTED
+#     define PNG_FP_EXPORT(ordinal, type, name, args)\
+         PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
+#     ifndef PNG_VERSION_INFO_ONLY
+         typedef struct png_incomplete png_double;
+         typedef png_double*           png_doublep;
+         typedef const png_double*     png_const_doublep;
+         typedef png_double**          png_doublepp;
+#     endif
+#  endif
+#endif
+#ifndef PNG_FIXED_EXPORT
+#  ifndef PNG_FIXED_POINT_SUPPORTED
+#     define PNG_FIXED_EXPORT(ordinal, type, name, args)\
+         PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
+#  endif
+#endif
+
+#include "png.h"
+
+/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */
+#ifndef PNG_DLL_EXPORT
+#  define PNG_DLL_EXPORT
+#endif
+
+/* This is a global switch to set the compilation for an installed system
+ * (a release build).  It can be set for testing debug builds to ensure that
+ * they will compile when the build type is switched to RC or STABLE, the
+ * default is just to use PNG_LIBPNG_BUILD_BASE_TYPE.  Set this in CPPFLAGS
+ * with either:
+ *
+ *   -DPNG_RELEASE_BUILD Turns on the release compile path
+ *   -DPNG_RELEASE_BUILD=0 Turns it off
+ * or in your pngusr.h with
+ *   #define PNG_RELEASE_BUILD=1 Turns on the release compile path
+ *   #define PNG_RELEASE_BUILD=0 Turns it off
+ */
+#ifndef PNG_RELEASE_BUILD
+#  define PNG_RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC)
+#endif
+
+/* SECURITY and SAFETY:
+ *
+ * libpng is built with support for internal limits on image dimensions and
+ * memory usage.  These are documented in scripts/pnglibconf.dfa of the
+ * source and recorded in the machine generated header file pnglibconf.h.
+ */
+
+/* If you are running on a machine where you cannot allocate more
+ * than 64K of memory at once, uncomment this.  While libpng will not
+ * normally need that much memory in a chunk (unless you load up a very
+ * large file), zlib needs to know how big of a chunk it can use, and
+ * libpng thus makes sure to check any memory allocation to verify it
+ * will fit into memory.
+ *
+ * zlib provides 'MAXSEG_64K' which, if defined, indicates the
+ * same limit and pngconf.h (already included) sets the limit
+ * if certain operating systems are detected.
+ */
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
+#  define PNG_MAX_MALLOC_64K
+#endif
+
+#ifndef PNG_UNUSED
+/* Unused formal parameter warnings are silenced using the following macro
+ * which is expected to have no bad effects on performance (optimizing
+ * compilers will probably remove it entirely).  Note that if you replace
+ * it with something other than whitespace, you must include the terminating
+ * semicolon.
+ */
+#  define PNG_UNUSED(param) (void)param;
+#endif
+
+/* Just a little check that someone hasn't tried to define something
+ * contradictory.
+ */
+#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
+#  undef PNG_ZBUF_SIZE
+#  define PNG_ZBUF_SIZE 65536L
+#endif
+
+/* If warnings or errors are turned off the code is disabled or redirected here.
+ * From 1.5.4 functions have been added to allow very limited formatting of
+ * error and warning messages - this code will also be disabled here.
+ */
+#ifdef PNG_WARNINGS_SUPPORTED
+#  define PNG_WARNING_PARAMETERS(p) png_warning_parameters p;
+#else
+#  define png_warning_parameter(p,number,string) ((void)0)
+#  define png_warning_parameter_unsigned(p,number,format,value) ((void)0)
+#  define png_warning_parameter_signed(p,number,format,value) ((void)0)
+#  define png_formatted_warning(pp,p,message) ((void)(pp))
+#  define PNG_WARNING_PARAMETERS(p)
+#endif
+#ifndef PNG_ERROR_TEXT_SUPPORTED
+#  define png_fixed_error(s1,s2) png_err(s1)
+#endif
+
+/* Some fixed point APIs are still required even if not exported because
+ * they get used by the corresponding floating point APIs.  This magic
+ * deals with this:
+ */
+#ifdef PNG_FIXED_POINT_SUPPORTED
+#  define PNGFAPI PNGAPI
+#else
+#  define PNGFAPI /* PRIVATE */
+#endif
+
+#ifndef PNG_VERSION_INFO_ONLY
+/* Other defines specific to compilers can go here.  Try to keep
+ * them inside an appropriate ifdef/endif pair for portability.
+ */
+
+/* C allows up-casts from (void*) to any pointer and (const void*) to any
+ * pointer to a const object.  C++ regards this as a type error and requires an
+ * explicit, static, cast and provides the static_cast<> rune to ensure that
+ * const is not cast away.
+ */
+#ifdef __cplusplus
+#  define png_voidcast(type, value) static_cast<type>(value)
+#  define png_constcast(type, value) const_cast<type>(value)
+#  define png_aligncast(type, value) \
+   static_cast<type>(static_cast<void*>(value))
+#  define png_aligncastconst(type, value) \
+   static_cast<type>(static_cast<const void*>(value))
+#else
+#  define png_voidcast(type, value) (value)
+#  define png_constcast(type, value) ((type)(void*)(const void*)(value))
+#  define png_aligncast(type, value) ((void*)(value))
+#  define png_aligncastconst(type, value) ((const void*)(value))
+#endif /* __cplusplus */
+
+#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\
+    defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
+   /* png.c requires the following ANSI-C constants if the conversion of
+    * floating point to ASCII is implemented therein:
+    *
+    *  DBL_DIG  Maximum number of decimal digits (can be set to any constant)
+    *  DBL_MIN  Smallest normalized fp number (can be set to an arbitrary value)
+    *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)
+    */
+#  include <float.h>
+
+#  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
+    defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
+   /* We need to check that <math.h> hasn't already been included earlier
+    * as it seems it doesn't agree with <fp.h>, yet we should really use
+    * <fp.h> if possible.
+    */
+#    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
+#      include <fp.h>
+#    endif
+#  else
+#    include <math.h>
+#  endif
+#  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
+   /* Amiga SAS/C: We must include builtin FPU functions when compiling using
+    * MATH=68881
+    */
+#    include <m68881.h>
+#  endif
+#endif
+
+/* This provides the non-ANSI (far) memory allocation routines. */
+#if defined(__TURBOC__) && defined(__MSDOS__)
+#  include <mem.h>
+#  include <alloc.h>
+#endif
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#  include <windows.h>
+#endif
+#endif /* PNG_VERSION_INFO_ONLY */
+
+/* Moved here around 1.5.0beta36 from pngconf.h */
+/* Users may want to use these so they are not private.  Any library
+ * functions that are passed far data must be model-independent.
+ */
+
+/* Platform-independent functions */
+#ifndef PNG_ABORT
+#  define PNG_ABORT() abort()
+#endif
+
+/* These macros may need to be architecture dependent. */
+#define PNG_ALIGN_NONE      0 /* do not use data alignment */
+#define PNG_ALIGN_ALWAYS    1 /* assume unaligned accesses are OK */
+#ifdef offsetof
+#  define PNG_ALIGN_OFFSET  2 /* use offsetof to determine alignment */
+#else
+#  define PNG_ALIGN_OFFSET -1 /* prevent the use of this */
+#endif
+#define PNG_ALIGN_SIZE      3 /* use sizeof to determine alignment */
+
+#ifndef PNG_ALIGN_TYPE
+   /* Default to using aligned access optimizations and requiring alignment to a
+    * multiple of the data type size.  Override in a compiler specific fashion
+    * if necessary by inserting tests here:
+    */
+#  define PNG_ALIGN_TYPE PNG_ALIGN_SIZE
+#endif
+
+#if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE
+   /* This is used because in some compiler implementations non-aligned
+    * structure members are supported, so the offsetof approach below fails.
+    * Set PNG_ALIGN_SIZE=0 for compiler combinations where unaligned access
+    * is good for performance.  Do not do this unless you have tested the
+    * result and understand it.
+    */
+#  define png_alignof(type) (sizeof(type))
+#else
+#  if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET
+#    define png_alignof(type) offsetof(struct{char c; type t;}, t)
+#  else
+#    if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS
+#      define png_alignof(type) 1
+#    endif
+     /* Else leave png_alignof undefined to prevent use thereof */
+#  endif
+#endif
+
+/* This implicitly assumes alignment is always a multiple of 2. */
+#ifdef png_alignof
+#  define png_isaligned(ptr, type) \
+   (((type)(size_t)((const void*)(ptr)) & (type)(png_alignof(type)-1)) == 0)
+#else
+#  define png_isaligned(ptr, type) 0
+#endif
+
+/* End of memory model/platform independent support */
+/* End of 1.5.0beta36 move from pngconf.h */
+
+/* CONSTANTS and UTILITY MACROS
+ * These are used internally by libpng and not exposed in the API
+ */
+
+/* Various modes of operation.  Note that after an init, mode is set to
+ * zero automatically when the structure is created.  Three of these
+ * are defined in png.h because they need to be visible to applications
+ * that call png_set_unknown_chunk().
+ */
+/* #define PNG_HAVE_IHDR            0x01U (defined in png.h) */
+/* #define PNG_HAVE_PLTE            0x02U (defined in png.h) */
+#define PNG_HAVE_IDAT               0x04U
+/* #define PNG_AFTER_IDAT           0x08U (defined in png.h) */
+#define PNG_HAVE_IEND               0x10U
+                   /*               0x20U (unused) */
+                   /*               0x40U (unused) */
+                   /*               0x80U (unused) */
+#define PNG_HAVE_CHUNK_HEADER      0x100U
+#define PNG_WROTE_tIME             0x200U
+#define PNG_WROTE_INFO_BEFORE_PLTE 0x400U
+#define PNG_BACKGROUND_IS_GRAY     0x800U
+#define PNG_HAVE_PNG_SIGNATURE    0x1000U
+#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000U /* Have another chunk after IDAT */
+                   /*             0x4000U (unused) */
+#define PNG_IS_READ_STRUCT        0x8000U /* Else is a write struct */
+
+/* Flags for the transformations the PNG library does on the image data */
+#define PNG_BGR                 0x0001U
+#define PNG_INTERLACE           0x0002U
+#define PNG_PACK                0x0004U
+#define PNG_SHIFT               0x0008U
+#define PNG_SWAP_BYTES          0x0010U
+#define PNG_INVERT_MONO         0x0020U
+#define PNG_QUANTIZE            0x0040U
+#define PNG_COMPOSE             0x0080U    /* Was PNG_BACKGROUND */
+#define PNG_BACKGROUND_EXPAND   0x0100U
+#define PNG_EXPAND_16           0x0200U    /* Added to libpng 1.5.2 */
+#define PNG_16_TO_8             0x0400U    /* Becomes 'chop' in 1.5.4 */
+#define PNG_RGBA                0x0800U
+#define PNG_EXPAND              0x1000U
+#define PNG_GAMMA               0x2000U
+#define PNG_GRAY_TO_RGB         0x4000U
+#define PNG_FILLER              0x8000U
+#define PNG_PACKSWAP           0x10000U
+#define PNG_SWAP_ALPHA         0x20000U
+#define PNG_STRIP_ALPHA        0x40000U
+#define PNG_INVERT_ALPHA       0x80000U
+#define PNG_USER_TRANSFORM    0x100000U
+#define PNG_RGB_TO_GRAY_ERR   0x200000U
+#define PNG_RGB_TO_GRAY_WARN  0x400000U
+#define PNG_RGB_TO_GRAY       0x600000U /* two bits, RGB_TO_GRAY_ERR|WARN */
+#define PNG_ENCODE_ALPHA      0x800000U /* Added to libpng-1.5.4 */
+#define PNG_ADD_ALPHA        0x1000000U /* Added to libpng-1.2.7 */
+#define PNG_EXPAND_tRNS      0x2000000U /* Added to libpng-1.2.9 */
+#define PNG_SCALE_16_TO_8    0x4000000U /* Added to libpng-1.5.4 */
+                       /*    0x8000000U unused */
+                       /*   0x10000000U unused */
+                       /*   0x20000000U unused */
+                       /*   0x40000000U unused */
+/* Flags for png_create_struct */
+#define PNG_STRUCT_PNG   0x0001U
+#define PNG_STRUCT_INFO  0x0002U
+
+/* Flags for the png_ptr->flags rather than declaring a byte for each one */
+#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001U
+#define PNG_FLAG_ZSTREAM_INITIALIZED      0x0002U /* Added to libpng-1.6.0 */
+                                  /*      0x0004U    unused */
+#define PNG_FLAG_ZSTREAM_ENDED            0x0008U /* Added to libpng-1.6.0 */
+                                  /*      0x0010U    unused */
+                                  /*      0x0020U    unused */
+#define PNG_FLAG_ROW_INIT                 0x0040U
+#define PNG_FLAG_FILLER_AFTER             0x0080U
+#define PNG_FLAG_CRC_ANCILLARY_USE        0x0100U
+#define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200U
+#define PNG_FLAG_CRC_CRITICAL_USE         0x0400U
+#define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800U
+#define PNG_FLAG_ASSUME_sRGB              0x1000U /* Added to libpng-1.5.4 */
+#define PNG_FLAG_OPTIMIZE_ALPHA           0x2000U /* Added to libpng-1.5.4 */
+#define PNG_FLAG_DETECT_UNINITIALIZED     0x4000U /* Added to libpng-1.5.4 */
+/* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000U */
+/* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS      0x10000U */
+#define PNG_FLAG_LIBRARY_MISMATCH        0x20000U
+#define PNG_FLAG_STRIP_ERROR_NUMBERS     0x40000U
+#define PNG_FLAG_STRIP_ERROR_TEXT        0x80000U
+#define PNG_FLAG_BENIGN_ERRORS_WARN     0x100000U /* Added to libpng-1.4.0 */
+#define PNG_FLAG_APP_WARNINGS_WARN      0x200000U /* Added to libpng-1.6.0 */
+#define PNG_FLAG_APP_ERRORS_WARN        0x400000U /* Added to libpng-1.6.0 */
+                                  /*    0x800000U    unused */
+                                  /*   0x1000000U    unused */
+                                  /*   0x2000000U    unused */
+                                  /*   0x4000000U    unused */
+                                  /*   0x8000000U    unused */
+                                  /*  0x10000000U    unused */
+                                  /*  0x20000000U    unused */
+                                  /*  0x40000000U    unused */
+
+#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
+                                     PNG_FLAG_CRC_ANCILLARY_NOWARN)
+
+#define PNG_FLAG_CRC_CRITICAL_MASK  (PNG_FLAG_CRC_CRITICAL_USE | \
+                                     PNG_FLAG_CRC_CRITICAL_IGNORE)
+
+#define PNG_FLAG_CRC_MASK           (PNG_FLAG_CRC_ANCILLARY_MASK | \
+                                     PNG_FLAG_CRC_CRITICAL_MASK)
+
+/* Save typing and make code easier to understand */
+
+#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
+   abs((int)((c1).green) - (int)((c2).green)) + \
+   abs((int)((c1).blue) - (int)((c2).blue)))
+
+/* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255
+ * by dividing by 257 *with rounding*.  This macro is exact for the given range.
+ * See the discourse in pngrtran.c png_do_scale_16_to_8.  The values in the
+ * macro were established by experiment (modifying the added value).  The macro
+ * has a second variant that takes a value already scaled by 255 and divides by
+ * 65535 - this has a maximum error of .502.  Over the range 0..65535*65535 it
+ * only gives off-by-one errors and only for 0.5% (1 in 200) of the values.
+ */
+#define PNG_DIV65535(v24) (((v24) + 32895) >> 16)
+#define PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255)
+
+/* Added to libpng-1.2.6 JB */
+#define PNG_ROWBYTES(pixel_bits, width) \
+    ((pixel_bits) >= 8 ? \
+    ((size_t)(width) * (((size_t)(pixel_bits)) >> 3)) : \
+    (( ((size_t)(width) * ((size_t)(pixel_bits))) + 7) >> 3) )
+
+/* This returns the number of trailing bits in the last byte of a row, 0 if the
+ * last byte is completely full of pixels.  It is, in principle, (pixel_bits x
+ * width) % 8, but that would overflow for large 'width'.  The second macro is
+ * the same except that it returns the number of unused bits in the last byte;
+ * (8-TRAILBITS), but 0 when TRAILBITS is 0.
+ *
+ * NOTE: these macros are intended to be self-evidently correct and never
+ * overflow on the assumption that pixel_bits is in the range 0..255.  The
+ * arguments are evaluated only once and they can be signed (e.g. as a result of
+ * the integral promotions).  The result of the expression always has type
+ * (png_uint_32), however the compiler always knows it is in the range 0..7.
+ */
+#define PNG_TRAILBITS(pixel_bits, width) \
+    (((pixel_bits) * ((width) % (png_uint_32)8)) % 8)
+
+#define PNG_PADBITS(pixel_bits, width) \
+    ((8 - PNG_TRAILBITS(pixel_bits, width)) % 8)
+
+/* PNG_OUT_OF_RANGE returns true if value is outside the range
+ * ideal-delta..ideal+delta.  Each argument is evaluated twice.
+ * "ideal" and "delta" should be constants, normally simple
+ * integers, "value" a variable. Added to libpng-1.2.6 JB
+ */
+#define PNG_OUT_OF_RANGE(value, ideal, delta) \
+   ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
+
+/* Conversions between fixed and floating point, only defined if
+ * required (to make sure the code doesn't accidentally use float
+ * when it is supposedly disabled.)
+ */
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+/* The floating point conversion can't overflow, though it can and
+ * does lose accuracy relative to the original fixed point value.
+ * In practice this doesn't matter because png_fixed_point only
+ * stores numbers with very low precision.  The png_ptr and s
+ * arguments are unused by default but are there in case error
+ * checking becomes a requirement.
+ */
+#define png_float(png_ptr, fixed, s) (.00001 * (fixed))
+
+/* The fixed point conversion performs range checking and evaluates
+ * its argument multiple times, so must be used with care.  The
+ * range checking uses the PNG specification values for a signed
+ * 32-bit fixed point value except that the values are deliberately
+ * rounded-to-zero to an integral value - 21474 (21474.83 is roughly
+ * (2^31-1) * 100000). 's' is a string that describes the value being
+ * converted.
+ *
+ * NOTE: this macro will raise a png_error if the range check fails,
+ * therefore it is normally only appropriate to use this on values
+ * that come from API calls or other sources where an out of range
+ * error indicates a programming error, not a data error!
+ *
+ * NOTE: by default this is off - the macro is not used - because the
+ * function call saves a lot of code.
+ */
+#ifdef PNG_FIXED_POINT_MACRO_SUPPORTED
+#define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\
+    ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
+#endif
+/* else the corresponding function is defined below, inside the scope of the
+ * cplusplus test.
+ */
+#endif
+
+/* Constants for known chunk types.  If you need to add a chunk, define the name
+ * here.  For historical reasons these constants have the form png_<name>; i.e.
+ * the prefix is lower case.  Please use decimal values as the parameters to
+ * match the ISO PNG specification and to avoid relying on the C locale
+ * interpretation of character values.
+ *
+ * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values
+ * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string
+ * to be generated if required.
+ *
+ * PNG_32b correctly produces a value shifted by up to 24 bits, even on
+ * architectures where (int) is only 16 bits.
+ */
+#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
+#define PNG_U32(b1,b2,b3,b4) \
+   (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
+
+/* Constants for known chunk types.
+ *
+ * MAINTAINERS: If you need to add a chunk, define the name here.
+ * For historical reasons these constants have the form png_<name>; i.e.
+ * the prefix is lower case.  Please use decimal values as the parameters to
+ * match the ISO PNG specification and to avoid relying on the C locale
+ * interpretation of character values.  Please keep the list sorted.
+ *
+ * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk
+ * type.  In fact the specification does not express chunk types this way,
+ * however using a 32-bit value means that the chunk type can be read from the
+ * stream using exactly the same code as used for a 32-bit unsigned value and
+ * can be examined far more efficiently (using one arithmetic compare).
+ *
+ * Prior to 1.5.6 the chunk type constants were expressed as C strings.  The
+ * libpng API still uses strings for 'unknown' chunks and a macro,
+ * PNG_STRING_FROM_CHUNK, allows a string to be generated if required.  Notice
+ * that for portable code numeric values must still be used; the string "IHDR"
+ * is not portable and neither is PNG_U32('I', 'H', 'D', 'R').
+ *
+ * In 1.7.0 the definitions will be made public in png.h to avoid having to
+ * duplicate the same definitions in application code.
+ */
+#define png_IDAT PNG_U32( 73,  68,  65,  84)
+#define png_IEND PNG_U32( 73,  69,  78,  68)
+#define png_IHDR PNG_U32( 73,  72,  68,  82)
+#define png_PLTE PNG_U32( 80,  76,  84,  69)
+#define png_bKGD PNG_U32( 98,  75,  71,  68)
+#define png_cHRM PNG_U32( 99,  72,  82,  77)
+#define png_eXIf PNG_U32(101,  88,  73, 102) /* registered July 2017 */
+#define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
+#define png_gAMA PNG_U32(103,  65,  77,  65)
+#define png_gIFg PNG_U32(103,  73,  70, 103)
+#define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
+#define png_gIFx PNG_U32(103,  73,  70, 120)
+#define png_hIST PNG_U32(104,  73,  83,  84)
+#define png_iCCP PNG_U32(105,  67,  67,  80)
+#define png_iTXt PNG_U32(105,  84,  88, 116)
+#define png_oFFs PNG_U32(111,  70,  70, 115)
+#define png_pCAL PNG_U32(112,  67,  65,  76)
+#define png_pHYs PNG_U32(112,  72,  89, 115)
+#define png_sBIT PNG_U32(115,  66,  73,  84)
+#define png_sCAL PNG_U32(115,  67,  65,  76)
+#define png_sPLT PNG_U32(115,  80,  76,  84)
+#define png_sRGB PNG_U32(115,  82,  71,  66)
+#define png_sTER PNG_U32(115,  84,  69,  82)
+#define png_tEXt PNG_U32(116,  69,  88, 116)
+#define png_tIME PNG_U32(116,  73,  77,  69)
+#define png_tRNS PNG_U32(116,  82,  78,  83)
+#define png_zTXt PNG_U32(122,  84,  88, 116)
+
+/* The following will work on (signed char*) strings, whereas the get_uint_32
+ * macro will fail on top-bit-set values because of the sign extension.
+ */
+#define PNG_CHUNK_FROM_STRING(s)\
+   PNG_U32(0xff & (s)[0], 0xff & (s)[1], 0xff & (s)[2], 0xff & (s)[3])
+
+/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
+ * signed and the argument is a (char[])  This macro will fail miserably on
+ * systems where (char) is more than 8 bits.
+ */
+#define PNG_STRING_FROM_CHUNK(s,c)\
+   (void)(((char*)(s))[0]=(char)(((c)>>24) & 0xff), \
+   ((char*)(s))[1]=(char)(((c)>>16) & 0xff),\
+   ((char*)(s))[2]=(char)(((c)>>8) & 0xff), \
+   ((char*)(s))[3]=(char)((c & 0xff)))
+
+/* Do the same but terminate with a null character. */
+#define PNG_CSTRING_FROM_CHUNK(s,c)\
+   (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
+
+/* Test on flag values as defined in the spec (section 5.4): */
+#define PNG_CHUNK_ANCILLARY(c)   (1 & ((c) >> 29))
+#define PNG_CHUNK_CRITICAL(c)     (!PNG_CHUNK_ANCILLARY(c))
+#define PNG_CHUNK_PRIVATE(c)      (1 & ((c) >> 21))
+#define PNG_CHUNK_RESERVED(c)     (1 & ((c) >> 13))
+#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >>  5))
+
+/* Gamma values (new at libpng-1.5.4): */
+#define PNG_GAMMA_MAC_OLD 151724  /* Assume '1.8' is really 2.2/1.45! */
+#define PNG_GAMMA_MAC_INVERSE 65909
+#define PNG_GAMMA_sRGB_INVERSE 45455
+
+/* Almost everything below is C specific; the #defines above can be used in
+ * non-C code (so long as it is C-preprocessed) the rest of this stuff cannot.
+ */
+#ifndef PNG_VERSION_INFO_ONLY
+
+#include "pngstruct.h"
+#include "pnginfo.h"
+
+/* Validate the include paths - the include path used to generate pnglibconf.h
+ * must match that used in the build, or we must be using pnglibconf.h.prebuilt:
+ */
+#if PNG_ZLIB_VERNUM != 0 && PNG_ZLIB_VERNUM != ZLIB_VERNUM
+#  error ZLIB_VERNUM != PNG_ZLIB_VERNUM \
+      "-I (include path) error: see the notes in pngpriv.h"
+   /* This means that when pnglibconf.h was built the copy of zlib.h that it
+    * used is not the same as the one being used here.  Because the build of
+    * libpng makes decisions to use inflateInit2 and inflateReset2 based on the
+    * zlib version number and because this affects handling of certain broken
+    * PNG files the -I directives must match.
+    *
+    * The most likely explanation is that you passed a -I in CFLAGS. This will
+    * not work; all the preprocessor directives and in particular all the -I
+    * directives must be in CPPFLAGS.
+    */
+#endif
+
+/* This is used for 16-bit gamma tables -- only the top level pointers are
+ * const; this could be changed:
+ */
+typedef const png_uint_16p * png_const_uint_16pp;
+
+/* Added to libpng-1.5.7: sRGB conversion tables */
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
+   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
+#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
+PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
+   /* Convert from an sRGB encoded value 0..255 to a 16-bit linear value,
+    * 0..65535.  This table gives the closest 16-bit answers (no errors).
+    */
+#endif
+
+PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
+PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
+
+#define PNG_sRGB_FROM_LINEAR(linear) \
+  ((png_byte)(0xff & ((png_sRGB_base[(linear)>>15] \
+   + ((((linear) & 0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)))
+   /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
+    * encoded value with maximum error 0.646365.  Note that the input is not a
+    * 16-bit value; it has been multiplied by 255! */
+#endif /* SIMPLIFIED_READ/WRITE */
+
+
+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Internal functions; these are not exported from a DLL however because they
+ * are used within several of the C source files they have to be C extern.
+ *
+ * All of these functions must be declared with PNG_INTERNAL_FUNCTION.
+ */
+
+/* Zlib support */
+#define PNG_UNEXPECTED_ZLIB_RETURN (-7)
+PNG_INTERNAL_FUNCTION(void, png_zstream_error,(png_structrp png_ptr, int ret),
+   PNG_EMPTY);
+   /* Used by the zlib handling functions to ensure that z_stream::msg is always
+    * set before they return.
+    */
+
+#ifdef PNG_WRITE_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr,
+   png_compression_bufferp *list),PNG_EMPTY);
+   /* Free the buffer list used by the compressed write code. */
+#endif
+
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && \
+   !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
+   (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
+   defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
+   (defined(PNG_sCAL_SUPPORTED) && \
+   defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_fixed,(png_const_structrp png_ptr,
+   double fp, png_const_charp text),PNG_EMPTY);
+#endif
+
+/* Check the user version string for compatibility, returns false if the version
+ * numbers aren't compatible.
+ */
+PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr,
+   png_const_charp user_png_ver),PNG_EMPTY);
+
+/* Internal base allocator - no messages, NULL on failure to allocate.  This
+ * does, however, call the application provided allocator and that could call
+ * png_error (although that would be a bug in the application implementation.)
+ */
+PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_base,(png_const_structrp png_ptr,
+   png_alloc_size_t size),PNG_ALLOCATED);
+
+#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
+   defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
+/* Internal array allocator, outputs no error or warning messages on failure,
+ * just returns NULL.
+ */
+PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr,
+   int nelements, size_t element_size),PNG_ALLOCATED);
+
+/* The same but an existing array is extended by add_elements.  This function
+ * also memsets the new elements to 0 and copies the old elements.  The old
+ * array is not freed or altered.
+ */
+PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr,
+   png_const_voidp array, int old_elements, int add_elements,
+   size_t element_size),PNG_ALLOCATED);
+#endif /* text, sPLT or unknown chunks */
+
+/* Magic to create a struct when there is no struct to call the user supplied
+ * memory allocators.  Because error handling has not been set up the memory
+ * handlers can't safely call png_error, but this is an obscure and undocumented
+ * restriction so libpng has to assume that the 'free' handler, at least, might
+ * call png_error.
+ */
+PNG_INTERNAL_FUNCTION(png_structp,png_create_png_struct,
+   (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
+    png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn,
+    png_free_ptr free_fn),PNG_ALLOCATED);
+
+/* Free memory from internal libpng struct */
+PNG_INTERNAL_FUNCTION(void,png_destroy_png_struct,(png_structrp png_ptr),
+   PNG_EMPTY);
+
+/* Free an allocated jmp_buf (always succeeds) */
+PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
+
+/* Function to allocate memory for zlib.  PNGAPI is disallowed. */
+PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
+   PNG_ALLOCATED);
+
+/* Function to free memory for zlib.  PNGAPI is disallowed. */
+PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
+
+/* Next four functions are used internally as callbacks.  PNGCBAPI is required
+ * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3, changed to
+ * PNGCBAPI at 1.5.0
+ */
+
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
+    png_bytep data, size_t length),PNG_EMPTY);
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
+    png_bytep buffer, size_t length),PNG_EMPTY);
+#endif
+
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr,
+    png_bytep data, size_t length),PNG_EMPTY);
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+#  ifdef PNG_STDIO_SUPPORTED
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr),
+   PNG_EMPTY);
+#  endif
+#endif
+
+/* Reset the CRC variable */
+PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY);
+
+/* Write the "data" buffer to whatever output you are using */
+PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr,
+    png_const_bytep data, size_t length),PNG_EMPTY);
+
+/* Read and check the PNG file signature */
+PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr,
+   png_inforp info_ptr),PNG_EMPTY);
+
+/* Read the chunk header (length + type name) */
+PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr),
+   PNG_EMPTY);
+
+/* Read data from whatever input you are using into the "data" buffer */
+PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data,
+    size_t length),PNG_EMPTY);
+
+/* Read bytes into buf, and update png_ptr->crc */
+PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf,
+    png_uint_32 length),PNG_EMPTY);
+
+/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
+PNG_INTERNAL_FUNCTION(int,png_crc_finish,(png_structrp png_ptr,
+   png_uint_32 skip),PNG_EMPTY);
+
+/* Read the CRC from the file and compare it to the libpng calculated CRC */
+PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY);
+
+/* Calculate the CRC over a section of data.  Note that we are only
+ * passing a maximum of 64K on systems that have this as a memory limit,
+ * since this is the maximum buffer size we can specify.
+ */
+PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr,
+   png_const_bytep ptr, size_t length),PNG_EMPTY);
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY);
+#endif
+
+/* Write various chunks */
+
+/* Write the IHDR chunk, and update the png_struct with the necessary
+ * information.
+ */
+PNG_INTERNAL_FUNCTION(void,png_write_IHDR,(png_structrp png_ptr,
+   png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
+   int compression_method, int filter_method, int interlace_method),PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr,
+   png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_compress_IDAT,(png_structrp png_ptr,
+   png_const_bytep row_data, png_alloc_size_t row_data_length, int flush),
+   PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY);
+
+#ifdef PNG_WRITE_gAMA_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_gAMA_fixed,(png_structrp png_ptr,
+    png_fixed_point file_gamma),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_sBIT_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr,
+    png_const_color_8p sbit, int color_type),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_cHRM_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr,
+    const png_xy *xy), PNG_EMPTY);
+   /* The xy value must have been previously validated */
+#endif
+
+#ifdef PNG_WRITE_sRGB_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr,
+    int intent),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_eXIf_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_eXIf,(png_structrp png_ptr,
+    png_bytep exif, int num_exif),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_iCCP_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_iCCP,(png_structrp png_ptr,
+   png_const_charp name, png_const_bytep profile), PNG_EMPTY);
+   /* The profile must have been previously validated for correctness, the
+    * length comes from the first four bytes.  Only the base, deflate,
+    * compression is supported.
+    */
+#endif
+
+#ifdef PNG_WRITE_sPLT_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr,
+    png_const_sPLT_tp palette),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_tRNS_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_tRNS,(png_structrp png_ptr,
+    png_const_bytep trans, png_const_color_16p values, int number,
+    int color_type),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_bKGD_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_bKGD,(png_structrp png_ptr,
+    png_const_color_16p values, int color_type),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_hIST_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr,
+    png_const_uint_16p hist, int num_hist),PNG_EMPTY);
+#endif
+
+/* Chunks that have keywords */
+#ifdef PNG_WRITE_tEXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr,
+   png_const_charp key, png_const_charp text, size_t text_len),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_zTXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_zTXt,(png_structrp png_ptr, png_const_charp
+    key, png_const_charp text, int compression),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_iTXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr,
+    int compression, png_const_charp key, png_const_charp lang,
+    png_const_charp lang_key, png_const_charp text),PNG_EMPTY);
+#endif
+
+#ifdef PNG_TEXT_SUPPORTED  /* Added at version 1.0.14 and 1.2.4 */
+PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr,
+    png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_oFFs_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_oFFs,(png_structrp png_ptr,
+    png_int_32 x_offset, png_int_32 y_offset, int unit_type),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_pCAL_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_pCAL,(png_structrp png_ptr,
+    png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
+    png_const_charp units, png_charpp params),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_pHYs_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_pHYs,(png_structrp png_ptr,
+    png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
+    int unit_type),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_tIME_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_tIME,(png_structrp png_ptr,
+    png_const_timep mod_time),PNG_EMPTY);
+#endif
+
+#ifdef PNG_WRITE_sCAL_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_sCAL_s,(png_structrp png_ptr,
+    int unit, png_const_charp width, png_const_charp height),PNG_EMPTY);
+#endif
+
+/* Called when finished processing a row of data */
+PNG_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr),
+    PNG_EMPTY);
+
+/* Internal use only.   Called before first row of data */
+PNG_INTERNAL_FUNCTION(void,png_write_start_row,(png_structrp png_ptr),
+    PNG_EMPTY);
+
+/* Combine a row of data, dealing with alpha, etc. if requested.  'row' is an
+ * array of png_ptr->width pixels.  If the image is not interlaced or this
+ * is the final pass this just does a memcpy, otherwise the "display" flag
+ * is used to determine whether to copy pixels that are not in the current pass.
+ *
+ * Because 'png_do_read_interlace' (below) replicates pixels this allows this
+ * function to achieve the documented 'blocky' appearance during interlaced read
+ * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row'
+ * are not changed if they are not in the current pass, when display is 0.
+ *
+ * 'display' must be 0 or 1, otherwise the memcpy will be done regardless.
+ *
+ * The API always reads from the png_struct row buffer and always assumes that
+ * it is full width (png_do_read_interlace has already been called.)
+ *
+ * This function is only ever used to write to row buffers provided by the
+ * caller of the relevant libpng API and the row must have already been
+ * transformed by the read transformations.
+ *
+ * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed
+ * bitmasks for use within the code, otherwise runtime generated masks are used.
+ * The default is compile time masks.
+ */
+#ifndef PNG_USE_COMPILE_TIME_MASKS
+#  define PNG_USE_COMPILE_TIME_MASKS 1
+#endif
+PNG_INTERNAL_FUNCTION(void,png_combine_row,(png_const_structrp png_ptr,
+    png_bytep row, int display),PNG_EMPTY);
+
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+/* Expand an interlaced row: the 'row_info' describes the pass data that has
+ * been read in and must correspond to the pixels in 'row', the pixels are
+ * expanded (moved apart) in 'row' to match the final layout, when doing this
+ * the pixels are *replicated* to the intervening space.  This is essential for
+ * the correct operation of png_combine_row, above.
+ */
+PNG_INTERNAL_FUNCTION(void,png_do_read_interlace,(png_row_infop row_info,
+    png_bytep row, int pass, png_uint_32 transformations),PNG_EMPTY);
+#endif
+
+/* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */
+
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+/* Grab pixels out of a row for an interlaced pass */
+PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info,
+    png_bytep row, int pass),PNG_EMPTY);
+#endif
+
+/* Unfilter a row: check the filter value before calling this, there is no point
+ * calling it for PNG_FILTER_VALUE_NONE.
+ */
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
+
+#if PNG_ARM_NEON_OPT > 0
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
+    png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+#endif
+
+#if PNG_MIPS_MSA_OPT > 0
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_msa,(png_row_infop row_info,
+    png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_msa,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_msa,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_msa,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_msa,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_msa,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_msa,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+#endif
+
+#if PNG_POWERPC_VSX_OPT > 0
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_vsx,(png_row_infop row_info,
+    png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_vsx,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_vsx,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_vsx,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_vsx,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_vsx,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_vsx,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+#endif
+
+#if PNG_INTEL_SSE_IMPLEMENTATION > 0
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_sse2,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_sse2,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_sse2,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_sse2,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_sse2,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_sse2,(png_row_infop
+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
+#endif
+
+/* Choose the best filter to use and filter the row data */
+PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
+    png_row_infop row_info),PNG_EMPTY);
+
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr,
+   png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY);
+   /* Read 'avail_out' bytes of data from the IDAT stream.  If the output buffer
+    * is NULL the function checks, instead, for the end of the stream.  In this
+    * case a benign error will be issued if the stream end is not found or if
+    * extra data has to be consumed.
+    */
+PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr),
+   PNG_EMPTY);
+   /* This cleans up when the IDAT LZ stream does not end when the last image
+    * byte is read; there is still some pending input.
+    */
+
+PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
+   PNG_EMPTY);
+   /* Finish a row while reading, dealing with interlacing passes, etc. */
+#endif /* SEQUENTIAL_READ */
+
+/* Initialize the row buffers, etc. */
+PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
+
+#if ZLIB_VERNUM >= 0x1240
+PNG_INTERNAL_FUNCTION(int,png_zlib_inflate,(png_structrp png_ptr, int flush),
+      PNG_EMPTY);
+#  define PNG_INFLATE(pp, flush) png_zlib_inflate(pp, flush)
+#else /* Zlib < 1.2.4 */
+#  define PNG_INFLATE(pp, flush) inflate(&(pp)->zstream, flush)
+#endif /* Zlib < 1.2.4 */
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+/* Optional call to update the users info structure */
+PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+#endif
+
+/* Shared transform functions, defined in pngtran.c */
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
+    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(png_row_infop row_info,
+    png_bytep row, int at_start),PNG_EMPTY);
+#endif
+
+#ifdef PNG_16BIT_SUPPORTED
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_row_infop row_info,
+    png_bytep row),PNG_EMPTY);
+#endif
+#endif
+
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
+    defined(PNG_WRITE_PACKSWAP_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_row_infop row_info,
+    png_bytep row),PNG_EMPTY);
+#endif
+
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_row_infop row_info,
+    png_bytep row),PNG_EMPTY);
+#endif
+
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_row_infop row_info,
+    png_bytep row),PNG_EMPTY);
+#endif
+
+/* The following decodes the appropriate chunks, and does error correction,
+ * then calls the appropriate callback for the chunk if it is valid.
+ */
+
+/* Decode the IHDR chunk */
+PNG_INTERNAL_FUNCTION(void,png_handle_IHDR,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_handle_PLTE,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_handle_IEND,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+
+#ifdef PNG_READ_bKGD_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_bKGD,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_cHRM_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_eXIf_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_eXIf,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_gAMA_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_gAMA,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_hIST_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_iCCP_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif /* READ_iCCP */
+
+#ifdef PNG_READ_iTXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_oFFs_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_oFFs,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_pCAL_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_pCAL,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_pHYs_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_pHYs,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_sBIT_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_sBIT,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_sCAL_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_sPLT_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif /* READ_sPLT */
+
+#ifdef PNG_READ_sRGB_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_tEXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_tEXt,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_tIME_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_tIME,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_tRNS_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_tRNS,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_zTXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+#endif
+
+PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_const_structrp png_ptr,
+    png_uint_32 chunk_name),PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_check_chunk_length,(png_const_structrp png_ptr,
+    png_uint_32 chunk_length),PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length, int keep),PNG_EMPTY);
+   /* This is the function that gets called for unknown chunks.  The 'keep'
+    * argument is either non-zero for a known chunk that has been set to be
+    * handled as unknown or zero for an unknown chunk.  By default the function
+    * just skips the chunk or errors out if it is critical.
+    */
+
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
+    defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
+PNG_INTERNAL_FUNCTION(int,png_chunk_unknown_handling,
+    (png_const_structrp png_ptr, png_uint_32 chunk_name),PNG_EMPTY);
+   /* Exactly as the API png_handle_as_unknown() except that the argument is a
+    * 32-bit chunk name, not a string.
+    */
+#endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
+
+/* Handle the transformations for reading and writing */
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr,
+   png_row_infop row_info),PNG_EMPTY);
+#endif
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_do_write_transformations,(png_structrp png_ptr,
+   png_row_infop row_info),PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr),
+    PNG_EMPTY);
+#endif
+
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_push_read_chunk,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_read_sig,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr),
+    PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr,
+    png_bytep buffer, size_t buffer_length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr,
+    png_bytep buffer, size_t buffer_length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr),
+    PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
+   png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr,
+   png_inforp info_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr,
+   png_inforp info_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr,
+    png_bytep row),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_read_push_finish_row,(png_structrp png_ptr),
+    PNG_EMPTY);
+#  ifdef PNG_READ_tEXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+#  endif
+#  ifdef PNG_READ_zTXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+#  endif
+#  ifdef PNG_READ_iTXt_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr,
+    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
+    png_inforp info_ptr),PNG_EMPTY);
+#  endif
+
+#endif /* PROGRESSIVE_READ */
+
+/* Added at libpng version 1.6.0 */
+#ifdef PNG_GAMMA_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr,
+    png_colorspacerp colorspace, png_fixed_point gAMA), PNG_EMPTY);
+   /* Set the colorspace gamma with a value provided by the application or by
+    * the gAMA chunk on read.  The value will override anything set by an ICC
+    * profile.
+    */
+
+PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr,
+    png_inforp info_ptr), PNG_EMPTY);
+   /* Synchronize the info 'valid' flags with the colorspace */
+
+PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr,
+    png_inforp info_ptr), PNG_EMPTY);
+   /* Copy the png_struct colorspace to the info_struct and call the above to
+    * synchronize the flags.  Checks for NULL info_ptr and does nothing.
+    */
+#endif
+
+/* Added at libpng version 1.4.0 */
+#ifdef PNG_COLORSPACE_SUPPORTED
+/* These internal functions are for maintaining the colorspace structure within
+ * a png_info or png_struct (or, indeed, both).
+ */
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_chromaticities,
+   (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy,
+    int preferred), PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_endpoints,
+   (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ,
+    int preferred), PNG_EMPTY);
+
+#ifdef PNG_sRGB_SUPPORTED
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr,
+   png_colorspacerp colorspace, int intent), PNG_EMPTY);
+   /* This does set the colorspace gAMA and cHRM values too, but doesn't set the
+    * flags to write them, if it returns false there was a problem and an error
+    * message has already been output (but the colorspace may still need to be
+    * synced to record the invalid flag).
+    */
+#endif /* sRGB */
+
+#ifdef PNG_iCCP_SUPPORTED
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_ICC,(png_const_structrp png_ptr,
+   png_colorspacerp colorspace, png_const_charp name,
+   png_uint_32 profile_length, png_const_bytep profile, int color_type),
+   PNG_EMPTY);
+   /* The 'name' is used for information only */
+
+/* Routines for checking parts of an ICC profile. */
+#ifdef PNG_READ_iCCP_SUPPORTED
+PNG_INTERNAL_FUNCTION(int,png_icc_check_length,(png_const_structrp png_ptr,
+   png_colorspacerp colorspace, png_const_charp name,
+   png_uint_32 profile_length), PNG_EMPTY);
+#endif /* READ_iCCP */
+PNG_INTERNAL_FUNCTION(int,png_icc_check_header,(png_const_structrp png_ptr,
+   png_colorspacerp colorspace, png_const_charp name,
+   png_uint_32 profile_length,
+   png_const_bytep profile /* first 132 bytes only */, int color_type),
+   PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(int,png_icc_check_tag_table,(png_const_structrp png_ptr,
+   png_colorspacerp colorspace, png_const_charp name,
+   png_uint_32 profile_length,
+   png_const_bytep profile /* header plus whole tag table */), PNG_EMPTY);
+#ifdef PNG_sRGB_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_icc_set_sRGB,(
+   png_const_structrp png_ptr, png_colorspacerp colorspace,
+   png_const_bytep profile, uLong adler), PNG_EMPTY);
+   /* 'adler' is the Adler32 checksum of the uncompressed profile data. It may
+    * be zero to indicate that it is not available.  It is used, if provided,
+    * as a fast check on the profile when checking to see if it is sRGB.
+    */
+#endif
+#endif /* iCCP */
+
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_colorspace_set_rgb_coefficients,
+   (png_structrp png_ptr), PNG_EMPTY);
+   /* Set the rgb_to_gray coefficients from the colorspace Y values */
+#endif /* READ_RGB_TO_GRAY */
+#endif /* COLORSPACE */
+
+/* Added at libpng version 1.4.0 */
+PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr,
+    png_uint_32 width, png_uint_32 height, int bit_depth,
+    int color_type, int interlace_type, int compression_type,
+    int filter_type),PNG_EMPTY);
+
+/* Added at libpng version 1.5.10 */
+#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
+    defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_do_check_palette_indexes,
+   (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY);
+#endif
+
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
+PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr,
+   png_const_charp name),PNG_NORETURN);
+#endif
+
+/* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite
+ * the end.  Always leaves the buffer nul terminated.  Never errors out (and
+ * there is no error code.)
+ */
+PNG_INTERNAL_FUNCTION(size_t,png_safecat,(png_charp buffer, size_t bufsize,
+   size_t pos, png_const_charp string),PNG_EMPTY);
+
+/* Various internal functions to handle formatted warning messages, currently
+ * only implemented for warnings.
+ */
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
+/* Utility to dump an unsigned value into a buffer, given a start pointer and
+ * and end pointer (which should point just *beyond* the end of the buffer!)
+ * Returns the pointer to the start of the formatted string.  This utility only
+ * does unsigned values.
+ */
+PNG_INTERNAL_FUNCTION(png_charp,png_format_number,(png_const_charp start,
+   png_charp end, int format, png_alloc_size_t number),PNG_EMPTY);
+
+/* Convenience macro that takes an array: */
+#define PNG_FORMAT_NUMBER(buffer,format,number) \
+   png_format_number(buffer, buffer + (sizeof buffer), format, number)
+
+/* Suggested size for a number buffer (enough for 64 bits and a sign!) */
+#define PNG_NUMBER_BUFFER_SIZE 24
+
+/* These are the integer formats currently supported, the name is formed from
+ * the standard printf(3) format string.
+ */
+#define PNG_NUMBER_FORMAT_u     1 /* chose unsigned API! */
+#define PNG_NUMBER_FORMAT_02u   2
+#define PNG_NUMBER_FORMAT_d     1 /* chose signed API! */
+#define PNG_NUMBER_FORMAT_02d   2
+#define PNG_NUMBER_FORMAT_x     3
+#define PNG_NUMBER_FORMAT_02x   4
+#define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */
+#endif
+
+#ifdef PNG_WARNINGS_SUPPORTED
+/* New defines and members adding in libpng-1.5.4 */
+#  define PNG_WARNING_PARAMETER_SIZE 32
+#  define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */
+
+/* An l-value of this type has to be passed to the APIs below to cache the
+ * values of the parameters to a formatted warning message.
+ */
+typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][
+   PNG_WARNING_PARAMETER_SIZE];
+
+PNG_INTERNAL_FUNCTION(void,png_warning_parameter,(png_warning_parameters p,
+   int number, png_const_charp string),PNG_EMPTY);
+   /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters,
+    * including the trailing '\0'.
+    */
+PNG_INTERNAL_FUNCTION(void,png_warning_parameter_unsigned,
+   (png_warning_parameters p, int number, int format, png_alloc_size_t value),
+   PNG_EMPTY);
+   /* Use png_alloc_size_t because it is an unsigned type as big as any we
+    * need to output.  Use the following for a signed value.
+    */
+PNG_INTERNAL_FUNCTION(void,png_warning_parameter_signed,
+   (png_warning_parameters p, int number, int format, png_int_32 value),
+   PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_formatted_warning,(png_const_structrp png_ptr,
+   png_warning_parameters p, png_const_charp message),PNG_EMPTY);
+   /* 'message' follows the X/Open approach of using @1, @2 to insert
+    * parameters previously supplied using the above functions.  Errors in
+    * specifying the parameters will simply result in garbage substitutions.
+    */
+#endif
+
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+/* Application errors (new in 1.6); use these functions (declared below) for
+ * errors in the parameters or order of API function calls on read.  The
+ * 'warning' should be used for an error that can be handled completely; the
+ * 'error' for one which can be handled safely but which may lose application
+ * information or settings.
+ *
+ * By default these both result in a png_error call prior to release, while in a
+ * released version the 'warning' is just a warning.  However if the application
+ * explicitly disables benign errors (explicitly permitting the code to lose
+ * information) they both turn into warnings.
+ *
+ * If benign errors aren't supported they end up as the corresponding base call
+ * (png_warning or png_error.)
+ */
+PNG_INTERNAL_FUNCTION(void,png_app_warning,(png_const_structrp png_ptr,
+   png_const_charp message),PNG_EMPTY);
+   /* The application provided invalid parameters to an API function or called
+    * an API function at the wrong time, libpng can completely recover.
+    */
+
+PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr,
+   png_const_charp message),PNG_EMPTY);
+   /* As above but libpng will ignore the call, or attempt some other partial
+    * recovery from the error.
+    */
+#else
+#  define png_app_warning(pp,s) png_warning(pp,s)
+#  define png_app_error(pp,s) png_error(pp,s)
+#endif
+
+PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr,
+   png_const_charp message, int error),PNG_EMPTY);
+   /* Report a recoverable issue in chunk data.  On read this is used to report
+    * a problem found while reading a particular chunk and the
+    * png_chunk_benign_error or png_chunk_warning function is used as
+    * appropriate.  On write this is used to report an error that comes from
+    * data set via an application call to a png_set_ API and png_app_error or
+    * png_app_warning is used as appropriate.
+    *
+    * The 'error' parameter must have one of the following values:
+    */
+#define PNG_CHUNK_WARNING     0 /* never an error */
+#define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */
+#define PNG_CHUNK_ERROR       2 /* always an error */
+
+/* ASCII to FP interfaces, currently only implemented if sCAL
+ * support is required.
+ */
+#if defined(PNG_sCAL_SUPPORTED)
+/* MAX_DIGITS is actually the maximum number of characters in an sCAL
+ * width or height, derived from the precision (number of significant
+ * digits - a build time settable option) and assumptions about the
+ * maximum ridiculous exponent.
+ */
+#define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)
+
+#ifdef PNG_FLOATING_POINT_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr,
+   png_charp ascii, size_t size, double fp, unsigned int precision),
+   PNG_EMPTY);
+#endif /* FLOATING_POINT */
+
+#ifdef PNG_FIXED_POINT_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
+   png_charp ascii, size_t size, png_fixed_point fp),PNG_EMPTY);
+#endif /* FIXED_POINT */
+#endif /* sCAL */
+
+#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
+/* An internal API to validate the format of a floating point number.
+ * The result is the index of the next character.  If the number is
+ * not valid it will be the index of a character in the supposed number.
+ *
+ * The format of a number is defined in the PNG extensions specification
+ * and this API is strictly conformant to that spec, not anyone elses!
+ *
+ * The format as a regular expression is:
+ *
+ * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)?
+ *
+ * or:
+ *
+ * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)?
+ *
+ * The complexity is that either integer or fraction must be present and the
+ * fraction is permitted to have no digits only if the integer is present.
+ *
+ * NOTE: The dangling E problem.
+ *   There is a PNG valid floating point number in the following:
+ *
+ *       PNG floating point numbers are not greedy.
+ *
+ *   Working this out requires *TWO* character lookahead (because of the
+ *   sign), the parser does not do this - it will fail at the 'r' - this
+ *   doesn't matter for PNG sCAL chunk values, but it requires more care
+ *   if the value were ever to be embedded in something more complex.  Use
+ *   ANSI-C strtod if you need the lookahead.
+ */
+/* State table for the parser. */
+#define PNG_FP_INTEGER    0  /* before or in integer */
+#define PNG_FP_FRACTION   1  /* before or in fraction */
+#define PNG_FP_EXPONENT   2  /* before or in exponent */
+#define PNG_FP_STATE      3  /* mask for the above */
+#define PNG_FP_SAW_SIGN   4  /* Saw +/- in current state */
+#define PNG_FP_SAW_DIGIT  8  /* Saw a digit in current state */
+#define PNG_FP_SAW_DOT   16  /* Saw a dot in current state */
+#define PNG_FP_SAW_E     32  /* Saw an E (or e) in current state */
+#define PNG_FP_SAW_ANY   60  /* Saw any of the above 4 */
+
+/* These three values don't affect the parser.  They are set but not used.
+ */
+#define PNG_FP_WAS_VALID 64  /* Preceding substring is a valid fp number */
+#define PNG_FP_NEGATIVE 128  /* A negative number, including "-0" */
+#define PNG_FP_NONZERO  256  /* A non-zero value */
+#define PNG_FP_STICKY   448  /* The above three flags */
+
+/* This is available for the caller to store in 'state' if required.  Do not
+ * call the parser after setting it (the parser sometimes clears it.)
+ */
+#define PNG_FP_INVALID  512  /* Available for callers as a distinct value */
+
+/* Result codes for the parser (boolean - true meants ok, false means
+ * not ok yet.)
+ */
+#define PNG_FP_MAYBE      0  /* The number may be valid in the future */
+#define PNG_FP_OK         1  /* The number is valid */
+
+/* Tests on the sticky non-zero and negative flags.  To pass these checks
+ * the state must also indicate that the whole number is valid - this is
+ * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this
+ * is equivalent to PNG_FP_OK above.)
+ */
+#define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO)
+   /* NZ_MASK: the string is valid and a non-zero negative value */
+#define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO)
+   /* Z MASK: the string is valid and a non-zero value. */
+   /* PNG_FP_SAW_DIGIT: the string is valid. */
+#define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT)
+#define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)
+#define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)
+
+/* The actual parser.  This can be called repeatedly. It updates
+ * the index into the string and the state variable (which must
+ * be initialized to 0).  It returns a result code, as above.  There
+ * is no point calling the parser any more if it fails to advance to
+ * the end of the string - it is stuck on an invalid character (or
+ * terminated by '\0').
+ *
+ * Note that the pointer will consume an E or even an E+ and then leave
+ * a 'maybe' state even though a preceding integer.fraction is valid.
+ * The PNG_FP_WAS_VALID flag indicates that a preceding substring was
+ * a valid number.  It's possible to recover from this by calling
+ * the parser again (from the start, with state 0) but with a string
+ * that omits the last character (i.e. set the size to the index of
+ * the problem character.)  This has not been tested within libpng.
+ */
+PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string,
+   size_t size, int *statep, size_t *whereami),PNG_EMPTY);
+
+/* This is the same but it checks a complete string and returns true
+ * only if it just contains a floating point number.  As of 1.5.4 this
+ * function also returns the state at the end of parsing the number if
+ * it was valid (otherwise it returns 0.)  This can be used for testing
+ * for negative or zero values using the sticky flag.
+ */
+PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string,
+   size_t size),PNG_EMPTY);
+#endif /* pCAL || sCAL */
+
+#if defined(PNG_GAMMA_SUPPORTED) ||\
+    defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
+/* Added at libpng version 1.5.0 */
+/* This is a utility to provide a*times/div (rounded) and indicate
+ * if there is an overflow.  The result is a boolean - false (0)
+ * for overflow, true (1) if no overflow, in which case *res
+ * holds the result.
+ */
+PNG_INTERNAL_FUNCTION(int,png_muldiv,(png_fixed_point_p res, png_fixed_point a,
+   png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY);
+#endif
+
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
+/* Same deal, but issue a warning on overflow and return 0. */
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn,
+   (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by,
+   png_int_32 divided_by),PNG_EMPTY);
+#endif
+
+#ifdef PNG_GAMMA_SUPPORTED
+/* Calculate a reciprocal - used for gamma values.  This returns
+ * 0 if the argument is 0 in order to maintain an undefined value;
+ * there are no warnings.
+ */
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal,(png_fixed_point a),
+   PNG_EMPTY);
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+/* The same but gives a reciprocal of the product of two fixed point
+ * values.  Accuracy is suitable for gamma calculations but this is
+ * not exact - use png_muldiv for that.  Only required at present on read.
+ */
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal2,(png_fixed_point a,
+   png_fixed_point b),PNG_EMPTY);
+#endif
+
+/* Return true if the gamma value is significantly different from 1.0 */
+PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value),
+   PNG_EMPTY);
+#endif
+
+#ifdef PNG_READ_GAMMA_SUPPORTED
+/* Internal fixed point gamma correction.  These APIs are called as
+ * required to convert single values - they don't need to be fast,
+ * they are not used when processing image pixel values.
+ *
+ * While the input is an 'unsigned' value it must actually be the
+ * correct bit value - 0..255 or 0..65535 as required.
+ */
+PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr,
+   unsigned int value, png_fixed_point gamma_value),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(unsigned int value,
+   png_fixed_point gamma_value),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value,
+   png_fixed_point gamma_value),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr),
+   PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr,
+   int bit_depth),PNG_EMPTY);
+#endif
+
+/* SIMPLIFIED READ/WRITE SUPPORT */
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
+   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
+/* The internal structure that png_image::opaque points to. */
+typedef struct png_control
+{
+   png_structp png_ptr;
+   png_infop   info_ptr;
+   png_voidp   error_buf;           /* Always a jmp_buf at present. */
+
+   png_const_bytep memory;          /* Memory buffer. */
+   size_t          size;            /* Size of the memory buffer. */
+
+   unsigned int for_write       :1; /* Otherwise it is a read structure */
+   unsigned int owned_file      :1; /* We own the file in io_ptr */
+} png_control;
+
+/* Return the pointer to the jmp_buf from a png_control: necessary because C
+ * does not reveal the type of the elements of jmp_buf.
+ */
+#ifdef __cplusplus
+#  define png_control_jmp_buf(pc) (((jmp_buf*)((pc)->error_buf))[0])
+#else
+#  define png_control_jmp_buf(pc) ((pc)->error_buf)
+#endif
+
+/* Utility to safely execute a piece of libpng code catching and logging any
+ * errors that might occur.  Returns true on success, false on failure (either
+ * of the function or as a result of a png_error.)
+ */
+PNG_INTERNAL_CALLBACK(void,png_safe_error,(png_structp png_ptr,
+   png_const_charp error_message),PNG_NORETURN);
+
+#ifdef PNG_WARNINGS_SUPPORTED
+PNG_INTERNAL_CALLBACK(void,png_safe_warning,(png_structp png_ptr,
+   png_const_charp warning_message),PNG_EMPTY);
+#else
+#  define png_safe_warning 0/*dummy argument*/
+#endif
+
+PNG_INTERNAL_FUNCTION(int,png_safe_execute,(png_imagep image,
+   int (*function)(png_voidp), png_voidp arg),PNG_EMPTY);
+
+/* Utility to log an error; this also cleans up the png_image; the function
+ * always returns 0 (false).
+ */
+PNG_INTERNAL_FUNCTION(int,png_image_error,(png_imagep image,
+   png_const_charp error_message),PNG_EMPTY);
+
+#ifndef PNG_SIMPLIFIED_READ_SUPPORTED
+/* png_image_free is used by the write code but not exported */
+PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);
+#endif /* !SIMPLIFIED_READ */
+
+#endif /* SIMPLIFIED READ/WRITE */
+
+/* These are initialization functions for hardware specific PNG filter
+ * optimizations; list these here then select the appropriate one at compile
+ * time using the macro PNG_FILTER_OPTIMIZATIONS.  If the macro is not defined
+ * the generic code is used.
+ */
+#ifdef PNG_FILTER_OPTIMIZATIONS
+PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
+   unsigned int bpp), PNG_EMPTY);
+   /* Just declare the optimization that will be used */
+#else
+   /* List *all* the possible optimizations here - this branch is required if
+    * the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in
+    * CFLAGS in place of CPPFLAGS *and* uses symbol prefixing.
+    */
+#  if PNG_ARM_NEON_OPT > 0
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
+   (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
+#endif
+
+#if PNG_MIPS_MSA_OPT > 0
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_msa,
+   (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
+#endif
+
+#  if PNG_INTEL_SSE_IMPLEMENTATION > 0
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_sse2,
+   (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
+#  endif
+#endif
+
+PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,
+   png_const_charp key, png_bytep new_key), PNG_EMPTY);
+
+#if PNG_ARM_NEON_IMPLEMENTATION == 1
+PNG_INTERNAL_FUNCTION(void,
+                      png_riffle_palette_neon,
+                      (png_structrp),
+                      PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(int,
+                      png_do_expand_palette_rgba8_neon,
+                      (png_structrp,
+                       png_row_infop,
+                       png_const_bytep,
+                       const png_bytepp,
+                       const png_bytepp),
+                      PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(int,
+                      png_do_expand_palette_rgb8_neon,
+                      (png_structrp,
+                       png_row_infop,
+                       png_const_bytep,
+                       const png_bytepp,
+                       const png_bytepp),
+                      PNG_EMPTY);
+#endif
+
+/* Maintainer: Put new private prototypes here ^ */
+
+#include "pngdebug.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PNG_VERSION_INFO_ONLY */
+#endif /* PNGPRIV_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/c/tsl_status.h

@@ -0,0 +1,92 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_C_TSL_STATUS_H_
+#define TENSORFLOW_TSL_C_TSL_STATUS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct TSL_Status TSL_Status;
+
+// --------------------------------------------------------------------------
+// TSL_Code holds an error code.  The enum values here are identical to
+// corresponding values in error_codes.proto.
+typedef enum TSL_Code {
+  TSL_OK = 0,
+  TSL_CANCELLED = 1,
+  TSL_UNKNOWN = 2,
+  TSL_INVALID_ARGUMENT = 3,
+  TSL_DEADLINE_EXCEEDED = 4,
+  TSL_NOT_FOUND = 5,
+  TSL_ALREADY_EXISTS = 6,
+  TSL_PERMISSION_DENIED = 7,
+  TSL_UNAUTHENTICATED = 16,
+  TSL_RESOURCE_EXHAUSTED = 8,
+  TSL_FAILED_PRECONDITION = 9,
+  TSL_ABORTED = 10,
+  TSL_OUT_OF_RANGE = 11,
+  TSL_UNIMPLEMENTED = 12,
+  TSL_INTERNAL = 13,
+  TSL_UNAVAILABLE = 14,
+  TSL_DATA_LOSS = 15,
+} TSL_Code;
+
+// --------------------------------------------------------------------------
+
+// Return a new status object.
+extern TSL_Status* TSL_NewStatus(void);
+
+// Delete a previously created status object.
+extern void TSL_DeleteStatus(TSL_Status*);
+
+// Record <code, msg> in *s.  Any previous information is lost.
+// A common use is to clear a status: TSL_SetStatus(s, TSL_OK, "");
+extern void TSL_SetStatus(TSL_Status* s, TSL_Code code, const char* msg);
+
+// Record <key, value> as a payload in *s. The previous payload having the
+// same key (if any) is overwritten. Payload will not be added if the Status
+// is OK.
+extern void TSL_SetPayload(TSL_Status* s, const char* key, const char* value);
+
+// Iterates over the stored payloads and calls the `visitor(key, value)`
+// callable for each one. `key` and `value` is only usable during the callback.
+// `capture` will be passed to the callback without modification.
+typedef void (*TSL_PayloadVisitor)(const char* key, const char* value,
+                                   void* capture);
+extern void TSL_ForEachPayload(const TSL_Status* s, TSL_PayloadVisitor visitor,
+                               void* capture);
+
+// Convert from an I/O error code (e.g., errno) to a TSL_Status value.
+// Any previous information is lost. Prefer to use this instead of TSL_SetStatus
+// when the error comes from I/O operations.
+extern void TSL_SetStatusFromIOError(TSL_Status* s, int error_code,
+                                     const char* context);
+
+// Return the code record in *s.
+extern TSL_Code TSL_GetCode(const TSL_Status* s);
+
+// Return a pointer to the (null-terminated) error message in *s.  The
+// return value points to memory that is only usable until the next
+// mutation to *s.  Always returns an empty string if TSL_GetCode(s) is
+// TSL_OK.
+extern const char* TSL_Message(const TSL_Status* s);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif  // TENSORFLOW_TSL_C_TSL_STATUS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/c/tsl_status_helper.h

@@ -0,0 +1,32 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_C_TSL_STATUS_HELPER_H_
+#define TENSORFLOW_TSL_C_TSL_STATUS_HELPER_H_
+
+#include <memory>
+
+#include "tsl/c/tsl_status.h"
+#include "tsl/platform/status.h"
+
+namespace tsl {
+
+TSL_Code TSLCodeFromStatusCode(absl::StatusCode code);
+
+absl::StatusCode StatusCodeFromTSLCode(TSL_Code code);
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_C_TSL_STATUS_HELPER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/c/tsl_status_internal.h

@@ -0,0 +1,28 @@
+/* Copyright 2019 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_C_TSL_STATUS_INTERNAL_H_
+#define TENSORFLOW_TSL_C_TSL_STATUS_INTERNAL_H_
+
+#include "tsl/platform/status.h"
+
+// Internal structures used by the status C API. These are likely to change
+// and should not be depended on.
+
+struct TSL_Status {
+  tsl::Status status;
+};
+
+#endif  // TENSORFLOW_TSL_C_TSL_STATUS_INTERNAL_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/concurrency/async_value.h

@@ -0,0 +1,998 @@
+/* Copyright 2022 Google LLC. 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_CONCURRENCY_ASYNC_VALUE_H_
+#define TENSORFLOW_TSL_CONCURRENCY_ASYNC_VALUE_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/span.h"
+#include "tsl/concurrency/concurrent_vector.h"
+#include "tsl/concurrency/ref_count.h"
+
+namespace tsl {
+
+class NotifierListNode;
+
+namespace internal {
+
+template <typename T>
+class ConcreteAsyncValue;
+
+template <typename T>
+constexpr bool kMaybeBase = std::is_class<T>::value && !std::is_final<T>::value;
+
+// TODO(ezhulenev): Switch to `tsl::port::Aligned(Malloc|Free)` once TFRT will
+// be able to properly depend on TSL in the open source build.
+void* AlignedAlloc(size_t alignment, size_t size);
+void AlignedFree(void* ptr);
+
+}  // namespace internal
+
+// This is a future of the specified value type. Arbitrary C++ types may be used
+// here, even non-copyable types and expensive ones like tensors.
+//
+// An AsyncValue is in one of two states: unavailable or available. If it is in
+// the unavailable state, it may have a list of waiters which are notified when
+// the value transitions to another state.
+//
+// The actual payload data is stored in the templated subclass
+// ConcreteAsyncValue. This achieves good cache efficiency by storing the meta
+// data and the payload data in consecutive memory locations.
+class AsyncValue {
+ public:
+  ~AsyncValue();
+
+  // Return true if state is kUnconstructed.
+  bool IsUnconstructed() const;
+
+  // Return true if state is kConstructed.
+  bool IsConstructed() const;
+
+  // Return true if state is kConcrete.
+  bool IsConcrete() const;
+
+  // Return true if state is kError.
+  bool IsError() const;
+
+  // Return true if this async value is resolved to a concrete value or error.
+  bool IsAvailable() const;
+  bool IsUnavailable() const { return !IsAvailable(); }
+
+  // Return true if this is an IndirectAsyncValue that hasn't been resolved.
+  // Currently an IndirectAsyncValue is available if and only if it is resolved.
+  bool IsUnresolvedIndirect() const;
+
+  // Return true if this is an IndirectAsyncValue.
+  bool IsIndirect() const;
+
+  // Return reference count. This should be used for testing and debugging only.
+  uint32_t NumRef() const { return refcount_.load(std::memory_order_acquire); }
+
+  // Return true if reference count is 1.
+  bool IsUnique() const;
+
+  // Add a new reference to this object.
+  //
+  // Return this object for convenience. e.g. when a call-site wants to feed an
+  // AsyncValue object into a function call that takes the object at +1, we can
+  // write: foo(av->AddRef());
+  AsyncValue* AddRef() { return AddRef(1); }
+  AsyncValue* AddRef(uint32_t count);
+
+  // Drop a reference to this object, potentially deallocating it.
+  void DropRef() { DropRef(1); }
+  void DropRef(uint32_t count);
+
+  // Return the stored value as type T. For the consumer of the AsyncValue, this
+  // requires that the state be `kConcrete`. For the producer of the AsyncValue,
+  // the state may also be `constructed`, as long as the producer can ensure
+  // race-free access to the data (e.g. no concurrent writes and reads and no
+  // concurrent changing the state to `kError). For both cases, T must be the
+  // exact type or a base type of the payload type of this AsyncValue. When T is
+  // a base type of the payload type, the following additional conditions are
+  // required:
+  // 1) Both the payload type and T are polymorphic (have virtual function) or
+  //    neither are.
+  // 2) The payload type does not use multiple inheritance.
+  // The above conditions are required since we store only the offset of the
+  // payload type in AsyncValue as data_traits_.buf_offset. Violation of either
+  // 1) or 2) requires additional pointer adjustments to get the proper pointer
+  // for the base type, which we do not have sufficient information to perform
+  // at runtime.
+  template <typename T>
+  const T& get() const;
+
+  // Same as the const overload of get(), except for returning a non-const ref.
+  template <typename T>
+  T& get();
+
+  // Returns the underlying error. IsError() must be true.
+  const absl::Status& GetError() const;
+
+  // Returns the underlying error, or nullptr if there is none.
+  const absl::Status* GetErrorIfPresent() const;
+
+  template <typename T>
+  bool IsType() const {
+    return GetTypeId<T>() == type_id_;
+  }
+
+  // Change state to kConcrete. Requires that this AsyncValue
+  // previously have state constructed.
+  void SetStateConcrete();
+
+  // Construct the payload of the AsyncValue in place and change its state to
+  // kConcrete. Requires that this AsyncValue previously have state
+  // kUnconstructed or kConstructed.
+  template <typename T, typename... Args>
+  void emplace(Args&&... args);
+
+  void SetError(absl::Status status);
+
+  // If the value is available or becomes available, this calls the closure
+  // immediately.  Otherwise, adds the waiter to the waiter list and calls it
+  // when the value becomes available.
+  template <typename WaiterT>
+  void AndThen(WaiterT waiter);
+
+  // Return the total number of async values that are currently live in the
+  // process. This is intended for debugging/assertions only, and shouldn't be
+  // used for mainline logic in the runtime.
+  static size_t GetNumAsyncValueInstances() {
+    assert(AsyncValueAllocationTrackingEnabled() &&
+           "AsyncValue instance tracking disabled!");
+    return total_allocated_async_values_.load(std::memory_order_relaxed);
+  }
+
+  // Returns true if we track the number of alive AsyncValue instances in
+  // total_allocated_async_values_.
+  static bool AsyncValueAllocationTrackingEnabled() {
+    // For now we track the number of alive AsyncValue instances only in debug
+    // builds.
+#ifdef NDEBUG
+    return false;
+#else
+    return true;
+#endif
+  }
+
+  // What sort of AsyncValue this is.
+  //
+  // We make this an unsigned type so that loading the enum from the bitfield
+  // does not sign extend.
+  enum class Kind : uint8_t {
+    kConcrete = 0,  // ConcreteAsyncValue
+    kIndirect = 1,  // IndirectAsyncValue
+  };
+
+  // Return the kind of this AsyncValue.
+  Kind kind() const { return kind_; }
+
+  class State {
+   public:
+    // The state of AsyncValue.
+    enum StateEnum : int8_t {
+      // The underlying value's constructor is not called and the value is not
+      // available for consumption. This state can transition to kConstructed,
+      // kConcrete and kError.
+      kUnconstructed = 0,
+      // The underlying value's constructor is called but the value is not
+      // available for consumption. This state can transition to
+      // kConcrete and kError.
+      kConstructed = 1,
+      // The underlying value is available for consumption. This state can not
+      // transition to any other state.
+      kConcrete = 2,
+      // This AsyncValue is available and contains an error. This state can not
+      // transition to any other state.
+      kError = 3,
+    };
+
+    State(StateEnum s) : state_(s) {}  // NOLINT
+
+    operator StateEnum() { return state_; }  // NOLINT
+
+    // Return true if state is kUnconstructed.
+    bool IsUnconstructed() const { return state_ == kUnconstructed; }
+
+    // Return true if state is kConstructed.
+    bool IsConstructed() const { return state_ == kConstructed; }
+
+    // Return true if state is kConcrete.
+    bool IsConcrete() const { return state_ == kConcrete; }
+
+    // Return true if state is kError.
+    bool IsError() const { return state_ == kError; }
+
+    // Return true if this async value is resolved to a concrete value or error.
+    bool IsAvailable() const { return state_ == kConcrete || state_ == kError; }
+    bool IsUnavailable() const { return !IsAvailable(); }
+
+    const char* DebugString() const {
+      switch (state_) {
+        case kUnconstructed:
+          return "kUnconstructed";
+        case kConstructed:
+          return "kConstructed";
+        case kConcrete:
+          return "kConcrete";
+        case kError:
+          return "kError";
+      }
+    }
+
+   private:
+    StateEnum state_;
+  };
+
+  // Return which state this AsyncValue is in.
+  State state() const {
+    return waiters_and_state_.load(std::memory_order_acquire).state();
+  }
+
+ protected:
+  // -----------------------------------------------------------
+  // Implementation details follow.  Clients should ignore them.
+
+  // Utility template for tag dispatching.
+  template <typename T>
+  struct TypeTag {};
+
+  friend class IndirectAsyncValue;
+  template <typename T>
+  AsyncValue(Kind kind, State state, bool is_refcounted, TypeTag<T>)
+      : refcount_(1),
+        kind_(kind),
+        has_vtable_(std::is_polymorphic<T>()),
+        is_refcounted_(is_refcounted),
+        type_id_(GetTypeId<T>()),
+        waiters_and_state_(WaitersAndState(nullptr, state)) {
+    if (AsyncValueAllocationTrackingEnabled() && is_refcounted)
+      total_allocated_async_values_.fetch_add(1, std::memory_order_relaxed);
+  }
+
+  AsyncValue(Kind kind, State state, bool is_refcounted)
+      : refcount_(1),
+        kind_(kind),
+        has_vtable_(false),
+        is_refcounted_(is_refcounted),
+        type_id_(0),
+        waiters_and_state_(WaitersAndState(nullptr, state)) {
+    if (AsyncValueAllocationTrackingEnabled() && is_refcounted)
+      total_allocated_async_values_.fetch_add(1, std::memory_order_relaxed);
+  }
+
+  AsyncValue(const AsyncValue&) = delete;
+  AsyncValue& operator=(const AsyncValue&) = delete;
+
+  void NotifyAvailable(State available_state);
+  void Destroy();
+  void RunWaiters(NotifierListNode* list);
+
+  // IsTypeIdCompatible returns true if the type value stored in this AsyncValue
+  // instance can be safely cast to `T`. This is a conservative check. I.e.
+  // IsTypeIdCompatible may return true even if the value cannot be safely cast
+  // to `T`. However, if it returns false then the value definitely cannot be
+  // safely cast to `T`. This means it is useful mainly as a debugging aid for
+  // use in assert() etc.
+
+  template <typename T, std::enable_if_t<internal::kMaybeBase<T>>* = nullptr>
+  bool IsTypeIdCompatible() const {
+    // We can't do a GetTypeId<T> in this case because `T` might be an abstract
+    // class.  So we conservatively return true.
+    return true;
+  }
+
+  template <typename T, std::enable_if_t<!internal::kMaybeBase<T>>* = nullptr>
+  bool IsTypeIdCompatible() const {
+    return GetTypeId<T>() == type_id_;
+  }
+
+  // Return the ID of the given type. Note that at most 2^16-2 (approx. 64K)
+  // unique types can be used in AsyncValues, since the ID is 16 bits, and 0 and
+  // 2^16-1 are not allowed to be used as type IDs.
+  template <typename T>
+  static uint16_t GetTypeId() {
+    return internal::ConcreteAsyncValue<T>::concrete_type_id_;
+  }
+
+  // Creates a AsyncValue::TypeInfo object for `T` and store it in the global
+  // TypeInfo table. Returns the "type id" for `T` which currently happens to
+  // be one plus the index of this TypeInfo object in the TypeInfo table.
+  //
+  // This should only be called from the initializer for the static
+  // ConcreteAsyncValue concrete_type_id_ field.
+  template <typename T>
+  static uint16_t CreateTypeInfoAndReturnTypeId() {
+    return CreateTypeInfoAndReturnTypeIdImpl(
+        MakeTypeInfo<internal::ConcreteAsyncValue<T>>());
+  }
+
+  std::atomic<uint32_t> refcount_{1};
+
+  Kind kind_ : 2;
+  // has_vtable_ has the same value for a given payload type T. If we want to
+  // use the unused bits here for other purpose in the future, we can move
+  // has_vtable_ to a global vector<bool> indexed by type_id_.
+  const bool has_vtable_ : 1;
+
+  // When is_refcounted_ is false, `AddRef` and `DropRef` have no effect in
+  // optimized builds. We always do reference counting in debug builds to verify
+  // that async values used correctly and we do not have accidental dangling
+  // references.
+  const bool is_refcounted_ : 1;
+
+  // This is a 16-bit value that identifies the type.
+  uint16_t type_id_ = 0;
+
+  // The waiter list and the state are compacted into one single atomic word as
+  // accesses to them are tightly related. To change the state from unavailable
+  // (i.e. kUnconstructed or kConstructed) to available
+  // (i.e. kConcrete or kError), we also need to empty the waiter
+  // list. To add a node to the waiter list, we want to make sure the state is
+  // unavailable, otherwise we could run the new node immediately.
+  //
+  // Invariant: If the state is not available, then the waiter list must be
+  // nullptr.
+  struct WaitersAndState {
+    // We rely on the fact that all `NotifierListNode` values are aligned at
+    // least to 8 bytes and we can encode state in the lowest 3 bits. We use
+    // the conservative estimation of the minimal alignment of pointers returned
+    // from memory allocation functions.
+    //
+    // See: https://en.cppreference.com/w/cpp/types/max_align_t
+    static_assert(alignof(std::max_align_t) >= 8 &&
+                  sizeof(NotifierListNode*) == 8);
+
+    static constexpr uint64_t kStateMask = (1ull << 2) - 1;
+    static constexpr uint64_t kPointerMask = ~kStateMask;
+
+    WaitersAndState(NotifierListNode* ptr, State state) {
+      value = (reinterpret_cast<uintptr_t>(ptr) & kPointerMask) |
+              (state & kStateMask);
+    }
+
+    State state() const {
+      return State(static_cast<State::StateEnum>(value & kStateMask));
+    }
+
+    NotifierListNode* waiter() const {
+      return reinterpret_cast<NotifierListNode*>(value & kPointerMask);
+    }
+
+    uintptr_t value;
+  };
+
+  std::atomic<WaitersAndState> waiters_and_state_;
+
+  // We assume (and static_assert) that this is the offset of
+  // ConcreteAsyncValue::data_, which is the same as the offset of
+  // ConcreteAsyncValue::error_.
+  static constexpr int kDataOffset = 16;
+
+ private:
+  // Information about a ConcreteAsyncValue<T> subclass.
+  struct TypeInfo {
+    // Destructor returns the size of the derived AsyncValue to be deallocated.
+    using DestructorFn = size_t (*)(AsyncValue*);
+    using GetErrorFn = const absl::Status& (*)(const AsyncValue*);
+    using SetErrorFn = void (*)(AsyncValue*, absl::Status);
+    using HasDataFn = bool (*)(const AsyncValue*);
+
+    DestructorFn destructor;
+    GetErrorFn get_error;
+    SetErrorFn set_error;
+    HasDataFn has_data;
+  };
+
+  template <typename Derived>
+  static TypeInfo MakeTypeInfo() {
+    return TypeInfo{
+        [](AsyncValue* v) {
+          static_cast<Derived*>(v)->~Derived();
+          return sizeof(Derived);
+        },
+        [](const AsyncValue* v) -> const absl::Status& {
+          return static_cast<const Derived*>(v)->GetError();
+        },
+        [](AsyncValue* v, absl::Status status) {
+          static_cast<Derived*>(v)->SetError(std::move(status));
+        },
+        [](const AsyncValue* v) {
+          return static_cast<const Derived*>(v)->HasData();
+        },
+    };
+  }
+
+  static uint16_t CreateTypeInfoAndReturnTypeIdImpl(const TypeInfo& type_info);
+
+  template <typename T>
+  const T& GetConcreteValue() const;
+
+  // Get the TypeInfo instance for this AsyncValue.
+  const TypeInfo& GetTypeInfo() const;
+
+  using TypeInfoTable = internal::ConcurrentVector<TypeInfo>;
+
+  // Returns the TypeInfoTable instance (there is one per process).
+  static TypeInfoTable* GetTypeInfoTableSingleton();
+
+  void EnqueueWaiter(absl::AnyInvocable<void()> waiter,
+                     WaitersAndState old_value);
+
+  // This is a global counter of the number of AsyncValue instances currently
+  // live in the process.  This is intended to be used for debugging only, and
+  // is only kept in sync if AsyncValueAllocationTrackingEnabled() returns
+  // true.
+  static std::atomic<size_t> total_allocated_async_values_;
+};
+
+// We only optimize the code for 64-bit architectures for now.
+static_assert(sizeof(AsyncValue) == 16 || sizeof(void*) != 8,
+              "Unexpected size for AsyncValue");
+
+//===----------------------------------------------------------------------===//
+// Functions for awaiting on the async values.
+//===----------------------------------------------------------------------===//
+
+// Blocks the caller thread until the async value becomes available.
+void BlockUntilReady(AsyncValue* async_value);
+
+// Runs the `callee` when all async values become available.
+void RunWhenReady(absl::Span<AsyncValue* const> values,
+                  absl::AnyInvocable<void()> callee);
+void RunWhenReady(absl::Span<RCReference<AsyncValue> const> values,
+                  absl::AnyInvocable<void()> callee);
+
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+// Under the normal behavior, if an AsyncValue is in kConstructed state (i.e.
+// the payload data is constructed), it will destruct the payload data when the
+// AsyncValue enters the error state (e.g. on AsyncValue::SetError()).
+//
+// However, for the payload types that inherit from
+// `KeepAsyncValuePayloadOnError`, AsyncValue exhibits a different behavior: the
+// payload value if constructed will be kept valid when the AsyncValue goes into
+// the error state. This behavior is intended for use only in the TpuRuntime
+// code. All the other code shall *not* use this behavior. We keep this struct
+// in the `internal` namespace to indicate this restriction.
+struct KeepAsyncValuePayloadOnError {};
+
+// Async value itself is a container that either holds `absl::Status` (in error
+// state) or a concrete value of type `T` (in concrete state). Async value that
+// holds a status is typically a bad idea, and should be expressed as a plain
+// async value.
+//
+// Example:
+//  - Prefer `AsyncValueRef<Chain>` to `AsyncValueRef<absl::Status>`.
+//    Instead of a `Chain` it can be any other empty struct to signal that only
+//    the potential error is important.
+//
+//  - Prefer `AsyncValueRef<T>` to `AsyncValueRef<absl::StatusOr<T>>`.
+//    Similar to the `absl::StatusOr<T>` async value will be either in error
+//    state holding an `absl::Status` error, or in concrete state holding a
+//    value of type `T`.
+//
+// Subclass for storing the payload of the AsyncValue
+template <typename T>
+class ConcreteAsyncValue : public AsyncValue {
+ public:
+  // Tag type for making a ConcreteAsyncValue without calling underlying value's
+  // constructor.
+  struct UnconstructedPayload {
+    bool is_refcounted = true;
+  };
+
+  // Tag type for making a ConcreteAsyncValue with the underlying value
+  // constructed but not available for consumption.
+  struct ConstructedPayload {
+    bool is_refcounted = true;
+  };
+
+  // Tag type for making a ConcreteAsyncValue with the underlying value
+  // constructed and available for consumption.
+  struct ConcretePayload {
+    bool is_refcounted = true;
+  };
+
+  // Make a ConcreteAsyncValue with kUnconstructed state.
+  explicit ConcreteAsyncValue(UnconstructedPayload payload)
+      : AsyncValue(Kind::kConcrete, State::kUnconstructed,
+                   payload.is_refcounted, TypeTag<T>()) {
+    VerifyOffsets();
+  }
+
+  // Make a ConcreteAsyncValue with kError state.
+  explicit ConcreteAsyncValue(absl::Status status)
+      : AsyncValue(Kind::kConcrete, State::kError,
+                   /*is_refcounted=*/true, TypeTag<T>()),
+        data_store_{std::move(status)} {
+    VerifyOffsets();
+  }
+
+  // Make a ConcreteAsyncValue with kConstructed state.
+  template <typename... Args>
+  explicit ConcreteAsyncValue(ConstructedPayload payload, Args&&... args)
+      : AsyncValue(Kind::kConcrete, State::kConstructed, payload.is_refcounted,
+                   TypeTag<T>()),
+        data_store_{TypeTag<T>(), std::forward<Args>(args)...} {}
+
+  // Make a ConcreteAsyncValue with kConcrete state.
+  template <typename... Args>
+  explicit ConcreteAsyncValue(ConcretePayload payload, Args&&... args)
+      : AsyncValue(Kind::kConcrete, State::kConcrete, payload.is_refcounted,
+                   TypeTag<T>()),
+        data_store_{TypeTag<T>(), std::forward<Args>(args)...} {}
+
+  ~ConcreteAsyncValue() { Destroy(); }
+
+  // Return the underlying error. IsError() must return true.
+  const absl::Status& GetError() const {
+    assert(IsError());
+    return data_store_.error();
+  }
+
+  void SetError(absl::Status status) {
+    data_store_.SetError(state(), std::move(status));
+    NotifyAvailable(State::kError);
+  }
+
+  const T& get() const {
+    assert(HasData());
+    return data_store_.data();
+  }
+
+  T& get() {
+    assert(HasData());
+    return data_store_.data();
+  }
+
+  // Construct the payload of the AsyncValue in place and change its state to
+  // kConcrete. Requires that this AsyncValue previously have state
+  // unavailable.
+  template <typename... Args>
+  void emplace(Args&&... args) {
+    data_store_.EmplaceData(std::forward<Args>(args)...);
+    NotifyAvailable(State::kConcrete);
+  }
+
+  static bool classof(const AsyncValue* v) {
+    return v->kind() == AsyncValue::Kind::kConcrete;
+  }
+
+ private:
+  friend class AsyncValue;
+
+  // Data and error layout when the payload does not inherit from
+  // KeepAsyncValuePayloadOnError. This type destructs the payload value on
+  // error. It never keeps both data and error alive at the same time.
+  class DataOrError {
+   public:
+    DataOrError() {}
+
+    explicit DataOrError(absl::Status status)
+        : error_{new absl::Status(std::move(status))} {}
+
+    template <typename... Args>
+    explicit DataOrError(TypeTag<T>, Args&&... args)
+        : data_{std::forward<Args>(args)...} {}
+
+    ~DataOrError() {}
+
+    void Destroy(State s) {
+      if (s == State::kError) {
+        delete error_;
+      } else if (s == State::kConstructed || s == State::kConcrete) {
+        data_.~T();
+      }
+    }
+
+    void SetError(State s, absl::Status status) {
+      assert(s == State::kUnconstructed || s == State::kConstructed);
+      if (s == State::kConstructed) {
+        data_.~T();
+      }
+      error_ = new absl::Status(std::move(status));
+    }
+
+    template <typename... Args>
+    void EmplaceData(Args&&... args) {
+      new (&data_) T(std::forward<Args>(args)...);
+    }
+
+    bool HasData(State s) const {
+      return s == State::kConstructed || s == State::kConcrete;
+    }
+
+    absl::Status& error() { return *error_; }
+    T& data() { return data_; }
+    const absl::Status& error() const { return *error_; }
+    const T& data() const { return data_; }
+
+   private:
+    friend class ConcreteAsyncValue;
+    union {
+      absl::Status* error_;
+      T data_;
+    };
+  };
+
+  // Data and error layout when the payload inherits from
+  // KeepAsyncValuePayloadOnError. This type does to destruct the payload value
+  // on error. It may keep both data and error alive at the same time.
+  class DataAndError {
+   public:
+    explicit DataAndError(absl::Status status) { SetError(std::move(status)); }
+
+    template <typename... Args>
+    explicit DataAndError(TypeTag<T>, Args&&... args) {
+      EmplaceData(std::forward<Args>(args)...);
+    }
+
+    void Destroy(State s) {
+      if (HasData()) data().~T();
+      error_.reset();
+      has_data_ = false;
+    }
+
+    void SetError(State s, absl::Status status) {
+      assert(!error_);
+      error_ = std::make_unique<absl::Status>(std::move(status));
+    }
+
+    template <typename... Args>
+    void EmplaceData(Args&&... args) {
+      assert(!HasData());
+      new (&data_) T(std::forward<Args>(args)...);
+      has_data_ = true;
+    }
+
+    T& data() { return *reinterpret_cast<T*>(&data_); }
+    const T& data() const { return *reinterpret_cast<const T*>(&data_); }
+
+    bool HasData(State s) const { return has_data_; }
+    bool HasData() const { return has_data_; }
+    const absl::Status& error() const { return *error_; }
+    absl::Status& error() { return *error_; }
+
+   private:
+    friend class ConcreteAsyncValue;
+    using StorageT = typename std::aligned_storage<sizeof(T), alignof(T)>::type;
+
+    StorageT data_;
+    bool has_data_ = false;
+    std::unique_ptr<absl::Status> error_;
+  };
+
+  using DataStoreT =
+      std::conditional_t<std::is_base_of_v<KeepAsyncValuePayloadOnError, T>,
+                         DataAndError, DataOrError>;
+  DataStoreT data_store_;
+
+  void Destroy() { data_store_.Destroy(state()); }
+  bool HasData() const { return data_store_.HasData(state()); }
+
+  static void VerifyOffsets() {
+    static_assert(offsetof(ConcreteAsyncValue<T>, data_store_.data_) ==
+                      AsyncValue::kDataOffset,
+                  "Offset of ConcreteAsyncValue::data_ is assumed to be "
+                  "AsyncValue::kDataOffset == 16");
+    static_assert(offsetof(ConcreteAsyncValue<T>, data_store_.error_) ==
+                      AsyncValue::kDataOffset,
+                  "Offset of ConcreteAsyncValue::error_ is assumed to be "
+                  "AsyncValue::kDataOffset == 16");
+  }
+
+  static const uint16_t concrete_type_id_;
+};
+
+template <typename T>
+const uint16_t ConcreteAsyncValue<T>::concrete_type_id_ =
+    AsyncValue::CreateTypeInfoAndReturnTypeId<T>();
+}  // namespace internal
+
+struct DummyValueForErrorAsyncValue {};
+
+class ErrorAsyncValue
+    : public internal::ConcreteAsyncValue<DummyValueForErrorAsyncValue> {
+ public:
+  ErrorAsyncValue(absl::Status status)  // NOLINT
+      : internal::ConcreteAsyncValue<DummyValueForErrorAsyncValue>(
+            std::move(status)) {}
+};
+
+// IndirectAsyncValue represents an uncomputed AsyncValue of unspecified kind
+// and type. IndirectAsyncValue is used when an AsyncValue must be returned,
+// but the value it holds is not ready and the producer of the value doesn't
+// know what type it will ultimately be, or whether it will be an error.
+class IndirectAsyncValue : public AsyncValue {
+  friend class AsyncValue;
+
+ public:
+  IndirectAsyncValue()
+      : AsyncValue(Kind::kIndirect, State::kUnconstructed,
+                   /*is_refcounted=*/true) {}
+
+  IndirectAsyncValue* AddRef() { return AddRef(1); }
+  IndirectAsyncValue* AddRef(uint32_t count) {
+    return static_cast<IndirectAsyncValue*>(AsyncValue::AddRef(count));
+  }
+
+  // Mark this IndirectAsyncValue as forwarding to the specified value. This
+  // gives the IndirectAsyncValue a +1 reference.
+  // This method must be called at most once.
+  void ForwardTo(RCReference<AsyncValue> value);
+
+  static bool classof(const AsyncValue* v) {
+    return v->kind() == AsyncValue::Kind::kIndirect;
+  }
+
+  bool IsUnique() const {
+    // In addition to checking the refcount of this IndirectAsyncValue, we also
+    // need to check the refcount of the underlying value. If the underlying
+    // value is not available, we conservatively return false.
+    return (refcount_.load(std::memory_order_acquire) == 1) && IsAvailable() &&
+           value_->IsUnique();
+  }
+
+ private:
+  ~IndirectAsyncValue() { Destroy(); }
+
+  void Destroy() {
+    if (value_) {
+      value_->DropRef();
+      value_ = nullptr;
+    }
+  }
+
+  AsyncValue* value_ = nullptr;
+};
+
+// -----------------------------------------------------------
+// Implementation details follow.  Clients should ignore them.
+//
+inline AsyncValue::~AsyncValue() {
+  assert(waiters_and_state_.load().waiter() == nullptr &&
+         "An async value with waiters should never have refcount of zero");
+  if (AsyncValueAllocationTrackingEnabled() && is_refcounted_)
+    total_allocated_async_values_.fetch_sub(1, std::memory_order_relaxed);
+
+  // Catch use-after-free errors more eagerly, by triggering the size assertion
+  // in the 'get' accessor.
+  type_id_ = ~0;
+}
+
+inline bool AsyncValue::IsAvailable() const {
+  auto s = state();
+  return s == State::kConcrete || s == State::kError;
+}
+
+inline bool AsyncValue::IsError() const { return state() == State::kError; }
+
+inline bool AsyncValue::IsUnconstructed() const {
+  return state() == State::kUnconstructed;
+}
+
+inline bool AsyncValue::IsConstructed() const {
+  return state() == State::kConstructed;
+}
+
+inline bool AsyncValue::IsConcrete() const {
+  return state() == State::kConcrete;
+}
+
+// Return true if this is an IndirectAsyncValue that hasn't been resolved.
+// Currently an IndirectAsyncValue is available if and only if it is resolved.
+inline bool AsyncValue::IsUnresolvedIndirect() const {
+  return IsUnavailable() && (kind() == Kind::kIndirect);
+}
+
+inline bool AsyncValue::IsIndirect() const { return kind() == Kind::kIndirect; }
+
+inline AsyncValue* AsyncValue::AddRef(uint32_t count) {
+  // Always enable reference counting in debug builds to verify that the use of
+  // async values is "ref count correct". In optimized builds the async value
+  // owner is responsible for destructing the non-reference-counted async value.
+#if defined(NDEBUG)
+  if (!is_refcounted_) return this;
+#endif
+
+  if (count > 0) {
+    assert(refcount_.load(std::memory_order_relaxed) > 0);
+    // Increasing the reference counter can always be done with
+    // memory_order_relaxed: New references to an object can only be formed from
+    // an existing reference, and passing an existing reference from one thread
+    // to another must already provide any required synchronization.
+    refcount_.fetch_add(count, std::memory_order_relaxed);
+  }
+  return this;
+}
+
+inline void AsyncValue::DropRef(uint32_t count) {
+  // Always enable reference counting in debug builds to verify that the use of
+  // async values is "ref count correct". In optimized builds the async value
+  // owner is responsible for destructing the non-reference-counted async value.
+#if defined(NDEBUG)
+  if (!is_refcounted_) return;
+#endif
+
+  assert(refcount_.load(std::memory_order_relaxed) > 0);
+  // We expect that `count` argument will often equal the actual reference count
+  // here; optimize for that. If `count` == reference count, only an acquire
+  // barrier is needed to prevent the effects of the deletion from leaking
+  // before this point.
+  auto is_last_ref = refcount_.load(std::memory_order_acquire) == count;
+  if (!is_last_ref) {
+    // If `count` != reference count, a release barrier is needed in
+    // addition to an acquire barrier so that prior changes by this thread
+    // cannot be seen to occur after this decrement.
+    is_last_ref =
+        refcount_.fetch_sub(count, std::memory_order_acq_rel) == count;
+  }
+  // Destroy this value if the refcount drops to zero.
+  if (is_last_ref) {
+    Destroy();
+  }
+}
+
+template <typename T>
+const T& AsyncValue::GetConcreteValue() const {
+  // Make sure both T (the stored type) and BaseT have vtable_ptr or
+  // neither have the vtable_ptr.
+  assert(std::is_polymorphic<T>::value == has_vtable_);
+  assert(IsTypeIdCompatible<T>() && "Incorrect accessor");
+
+  const char* this_ptr = reinterpret_cast<const char*>(this);
+  return *reinterpret_cast<const T*>(this_ptr + AsyncValue::kDataOffset);
+}
+
+template <typename T>
+const T& AsyncValue::get() const {
+  auto s = state();
+  (void)s;
+
+  switch (kind()) {
+    case Kind::kConcrete:
+#ifndef NDEBUG
+      // TODO(ezhulenev): Use `DLOG_IF` when absl logging is available.
+      if (!GetTypeInfo().has_data(this)) {
+        std::cerr << "Cannot call get() when ConcreteAsyncValue"  // Crash OK
+                  << " isn't constructed; state: " << s.DebugString() << ","
+                  << " error message: "
+                  << (IsError() ? GetError().message() : "None");
+        std::abort();
+      }
+#endif  // NDEBUG
+      return GetConcreteValue<T>();
+    case Kind::kIndirect:
+#ifndef NDEBUG
+      // TODO(ezhulenev): Use `DLOG_IF` when absl logging is available.
+      if (s != State::kConcrete) {
+        std::cerr << "Cannot call get() when IndirectAsyncValue"  // Crash OK
+                  << " isn't concrete; state: " << s.DebugString() << ","
+                  << " error message: "
+                  << (IsError() ? GetError().message() : "None");
+        std::abort();
+      }
+#endif  // NDEBUG
+      auto* iv_value = static_cast<const IndirectAsyncValue*>(this)->value_;
+      assert(iv_value && "Indirect value not resolved");
+      return iv_value->get<T>();
+  }
+  assert(false && "unexpected AsyncValue kind");
+}
+
+template <typename T>
+T& AsyncValue::get() {
+  return const_cast<T&>(static_cast<const AsyncValue*>(this)->get<T>());
+}
+
+inline void AsyncValue::SetStateConcrete() {
+  assert(IsConstructed() && kind() == Kind::kConcrete);
+  NotifyAvailable(State::kConcrete);
+}
+
+template <typename T, typename... Args>
+void AsyncValue::emplace(Args&&... args) {
+  assert(GetTypeId<T>() == type_id_ && "Incorrect accessor");
+  assert(IsUnconstructed() && kind() == Kind::kConcrete);
+
+  static_cast<internal::ConcreteAsyncValue<T>*>(this)->emplace(
+      std::forward<Args>(args)...);
+}
+
+// Returns the underlying error, or nullptr if there is none.
+inline const absl::Status* AsyncValue::GetErrorIfPresent() const {
+  switch (kind()) {
+    case Kind::kConcrete: {
+      if (state() != State::kError) return nullptr;
+      return &GetTypeInfo().get_error(this);
+    }
+    case Kind::kIndirect: {
+      auto* iv_value = static_cast<const IndirectAsyncValue*>(this)->value_;
+      // Unresolved IndirectAsyncValues are not errors.
+      if (!iv_value) return nullptr;
+
+      assert(iv_value->kind() != Kind::kIndirect);
+      return iv_value->GetErrorIfPresent();
+    }
+  }
+}
+
+inline const absl::Status& AsyncValue::GetError() const {
+  auto* result = GetErrorIfPresent();
+  assert(result && "Cannot call GetError() when error isn't available.");
+  return *result;
+}
+
+template <typename WaiterT>
+void AsyncValue::AndThen(WaiterT waiter) {
+  // Clients generally want to use AndThen without them each having to check
+  // to see if the value is present. Check for them, and immediately run the
+  // lambda if it is already here.
+  auto old_value = waiters_and_state_.load(std::memory_order_acquire);
+  if (old_value.state() == State::kConcrete ||
+      old_value.state() == State::kError) {
+    assert(old_value.waiter() == nullptr);
+    waiter();
+    return;
+  }
+  EnqueueWaiter(std::forward<WaiterT>(waiter), old_value);
+}
+
+inline void AsyncValue::Destroy() {
+  // Copy `is_refcounted` flag before destroying the async value object.
+  bool was_ref_counted = is_refcounted_;
+
+  if (kind() == Kind::kIndirect) {
+    // Depending on what the benchmarks say, it might make sense to remove this
+    // explicit check and instead make ~IndirectAsyncValue go through the
+    // GetTypeInfo().destructor case below.
+    static_cast<IndirectAsyncValue*>(this)->~IndirectAsyncValue();
+    if (was_ref_counted) internal::AlignedFree(this);
+    return;
+  }
+
+  GetTypeInfo().destructor(this);
+  if (was_ref_counted) internal::AlignedFree(this);
+}
+
+inline bool AsyncValue::IsUnique() const {
+  if (kind() != Kind::kIndirect) {
+    return refcount_.load(std::memory_order_acquire) == 1;
+  }
+
+  // If it is an IndirectAsyncValue, we also need to check the refcount of the
+  // underlying value.
+  return static_cast<const IndirectAsyncValue*>(this)->IsUnique();
+}
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_CONCURRENCY_ASYNC_VALUE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/concurrency/chain.h

@@ -0,0 +1,25 @@
+/* Copyright 2022 Google LLC. 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_CONCURRENCY_CHAIN_H_
+#define TENSORFLOW_TSL_CONCURRENCY_CHAIN_H_
+
+namespace tsl {
+
+class Chain {};
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_CONCURRENCY_CHAIN_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/concurrency/concurrent_vector.h

@@ -0,0 +1,177 @@
+/* Copyright 2022 Google LLC. 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_CONCURRENCY_CONCURRENT_VECTOR_H_
+#define TENSORFLOW_TSL_CONCURRENCY_CONCURRENT_VECTOR_H_
+
+#include <algorithm>
+#include <atomic>
+#include <cassert>
+#include <memory>
+#include <vector>
+
+#include "absl/synchronization/mutex.h"
+#include "absl/types/span.h"
+
+namespace tsl {
+namespace internal {
+
+// A simple concurrent sequential container that allows concurrent reads and
+// writes and is optimized for read access. It is designed for the usage pattern
+// where objects are inserted once but are read many times. The key difference
+// between this data structure and std::vector is that when we re-allocate the
+// underlying buffer, we do not free the previous buffer. This allows us to
+// implement read access with a single atomic load.
+//
+// Sample usage:
+//
+// ConcurrentVector<T> vec;
+//
+// On the writer side, concurrent writers are allowed;
+//
+// size_t index1 = vec.emplace_back(args);
+// size_t index2 = vec.emplace_back(args);
+//
+// On the reader side, concurrent readers are allowed.
+//
+// auto& t1 = vec[index1];
+// auto& t2 = vec[index1];
+//
+// Requirements:
+//
+// Type T needs to be copyable.
+
+template <typename T>
+class ConcurrentVector {
+ public:
+  // Initialize the vector with the given initial_capapcity
+  explicit ConcurrentVector(size_t initial_capacity) : state_(0ull) {
+    // ConcurrentVector does not support inserting more than 2^64 elements,
+    // which should be more than enough for any reasonable use case.
+    all_allocated_elements_.reserve(65);
+    all_allocated_elements_.emplace_back();
+    auto& v = all_allocated_elements_.back();
+    v.reserve(std::max(static_cast<size_t>(1), initial_capacity));
+  }
+
+  T& operator[](size_t index) {
+    auto state = State::Decode(state_.load(std::memory_order_acquire));
+    assert(index < state.size);
+    // .data() is a workaround for libc++ assertions in operator[], which will
+    // cause data race when container is resized from another thread.
+    return all_allocated_elements_.data()[state.last_allocated].data()[index];
+  }
+
+  const T& operator[](size_t index) const {
+    auto state = State::Decode(state_.load(std::memory_order_acquire));
+    assert(index < state.size);
+    // .data() is a workaround for libc++ assertions in operator[], which will
+    // cause data race when container is resized from another thread.
+    return all_allocated_elements_.data()[state.last_allocated].data()[index];
+  }
+
+  absl::Span<const T> ToConstSpan() const {
+    auto state = State::Decode(state_.load(std::memory_order_acquire));
+    auto& storage = all_allocated_elements_[state.last_allocated];
+    // .data() is a workaround for libc++ assertions in operator[], which will
+    // cause data race when container is resized from another thread.
+    return absl::MakeConstSpan(storage.data(), state.size);
+  }
+
+  // Return the number of elements currently valid in this vector.  The vector
+  // only grows, so this is conservative w.r.t. the execution of the current
+  // thread.
+  size_t size() const {
+    return State::Decode(state_.load(std::memory_order_relaxed)).size;
+  }
+
+  // Insert a new element at the end. If the current buffer is full, we allocate
+  // a new buffer with twice as much capacity and copy the items in the
+  // previous buffer over.
+  //
+  // Returns the index of the newly inserted item.
+  template <typename... Args>
+  size_t emplace_back(Args&&... args) {
+    absl::MutexLock lock(&mutex_);
+
+    auto& last = all_allocated_elements_.back();
+
+    if (last.size() < last.capacity()) {
+      // There is still room in the current vector without reallocation. Just
+      // add the new element there.
+      last.emplace_back(std::forward<Args>(args)...);
+
+      // Increment the size of the concurrent vector.
+      auto state = State::Decode(state_.load(std::memory_order_relaxed));
+      state.size += 1;
+      state_.store(state.Encode(), std::memory_order_release);
+
+      return state.size - 1;  // return insertion index
+    }
+    // There is no more room in the current vector without reallocation.
+    // Allocate a new vector with twice as much capacity, copy the elements
+    // from the previous vector, and set elements_ to point to the data of the
+    // new vector.
+    auto& new_last = all_allocated_elements_.emplace_back();
+    auto& prev = *(all_allocated_elements_.rbegin() + 1);
+    new_last.reserve(prev.capacity() * 2);
+    assert(prev.size() == prev.capacity());
+
+    // Copy over the previous vector to the new vector.
+    new_last.insert(new_last.begin(), prev.begin(), prev.end());
+    new_last.emplace_back(std::forward<Args>(args)...);
+
+    // Increment the size of the concurrent vector and index of the last
+    // allocated vector.
+    auto state = State::Decode(state_.load(std::memory_order_relaxed));
+    state.last_allocated += 1;
+    state.size += 1;
+    state_.store(state.Encode(), std::memory_order_release);
+
+    return state.size - 1;  // return insertion index
+  }
+
+ private:
+  // Concurrent vector state layout:
+  // - Low 32 bits encode the index of the last allocated vector.
+  // - High 32 bits encode the size of the concurrent vector.
+  static constexpr uint64_t kLastAllocatedMask = (1ull << 32) - 1;
+  static constexpr uint64_t kSizeMask = ((1ull << 32) - 1) << 32;
+
+  struct State {
+    uint64_t last_allocated;  // index of last allocated vector
+    uint64_t size;            // size of the concurrent vector
+
+    static State Decode(uint64_t state) {
+      uint64_t last_allocated = (state & kLastAllocatedMask);
+      uint64_t size = (state & kSizeMask) >> 32;
+      return {last_allocated, size};
+    }
+
+    uint64_t Encode() const { return (size << 32) | last_allocated; }
+  };
+
+  // Stores/loads to/from this atomic used to enforce happens-before
+  // relationship between emplace_back and operator[].
+  std::atomic<uint64_t> state_;
+
+  absl::Mutex mutex_;
+  std::vector<std::vector<T>> all_allocated_elements_;
+};
+
+}  // namespace internal
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_CONCURRENCY_CONCURRENT_VECTOR_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/concurrency/ref_count.h

@@ -0,0 +1,260 @@
+/* Copyright 2022 Google LLC. 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_CONCURRENCY_REF_COUNT_H_
+#define TENSORFLOW_TSL_CONCURRENCY_REF_COUNT_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace tsl {
+
+#ifndef NDEBUG
+inline std::atomic<size_t> total_reference_counted_objects;
+
+// Return the total number of reference-counted objects that are currently
+// live in the process.  This is intended for debugging/assertions only, and
+// shouldn't be used for mainline logic in the runtime.
+inline size_t GetNumReferenceCountedObjects() {
+  return total_reference_counted_objects.load(std::memory_order_relaxed);
+}
+inline void AddNumReferenceCountedObjects() {
+  total_reference_counted_objects.fetch_add(1, std::memory_order_relaxed);
+}
+inline void DropNumReferenceCountedObjects() {
+  total_reference_counted_objects.fetch_sub(1, std::memory_order_relaxed);
+}
+#else
+inline void AddNumReferenceCountedObjects() {}
+inline void DropNumReferenceCountedObjects() {}
+#endif
+
+// This class is a common base class for things that need an atomic reference
+// count for ownership management.
+//
+// Subclasses of this are allowed to implement a Destroy() instance method,
+// which allows custom allocation/deallocation logic.
+//
+// This class intentionally doesn't have a virtual destructor or anything else
+// that would require a vtable, but subclasses can have one if they choose.
+template <typename SubClass>
+class ReferenceCounted {
+ public:
+  ReferenceCounted() : ReferenceCounted(1) {}
+  explicit ReferenceCounted(unsigned ref_count) : ref_count_(ref_count) {
+    AddNumReferenceCountedObjects();
+  }
+
+  ~ReferenceCounted() {
+    assert(ref_count_.load() == 0 &&
+           "Shouldn't destroy a reference counted object with references!");
+    DropNumReferenceCountedObjects();
+  }
+
+  // Not copyable or movable.
+  ReferenceCounted(const ReferenceCounted&) = delete;
+  ReferenceCounted& operator=(const ReferenceCounted&) = delete;
+
+  // Add a new reference to this object.
+  void AddRef() {
+    assert(ref_count_.load(std::memory_order_relaxed) >= 1);
+    // It is OK to use std::memory_order_relaxed here as it does not affect the
+    // ownership state of the object.
+    ref_count_.fetch_add(1, std::memory_order_relaxed);
+  }
+
+  // Drop a reference to this object, potentially deallocating it.
+  void DropRef() {
+    assert(ref_count_.load(std::memory_order_relaxed) > 0);
+
+    // If ref_count_==1, this object is owned only by the caller. Bypass a
+    // locked op in that case.
+    if (ref_count_.load(std::memory_order_acquire) == 1 ||
+        ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      // Make assert in ~ReferenceCounted happy
+      assert((ref_count_.store(0, std::memory_order_relaxed), true));
+      static_cast<SubClass*>(this)->Destroy();
+    }
+  }
+
+  // Return reference count. This should be used for testing and debugging only.
+  uint32_t NumRef() const { return ref_count_.load(); }
+
+  // Return true if reference count is 1.
+  bool IsUnique() const {
+    return ref_count_.load(std::memory_order_acquire) == 1;
+  }
+
+ protected:
+  // Subclasses are allowed to customize this, but the default implementation of
+  // Destroy() just deletes the pointer.
+  void Destroy() { delete static_cast<SubClass*>(this); }
+
+ private:
+  std::atomic<unsigned> ref_count_;
+};
+
+// This is a smart pointer that keeps the specified reference counted value
+// around.  It is move-only to avoid accidental copies, but it can be copied
+// explicitly.
+template <typename T>
+class RCReference {
+ public:
+  RCReference() : pointer_(nullptr) {}
+
+  RCReference(RCReference&& other) : pointer_(other.pointer_) {
+    other.pointer_ = nullptr;
+  }
+
+  RCReference(const RCReference& other) : pointer_(other.pointer_) {
+    if (pointer_) pointer_->AddRef();
+  }
+
+  RCReference& operator=(RCReference&& other) {
+    reset(other.pointer_);
+    other.pointer_ = nullptr;
+    return *this;
+  }
+
+  RCReference& operator=(const RCReference& other) {
+    reset(other.pointer_);
+    if (pointer_) pointer_->AddRef();
+    return *this;
+  }
+
+  // Support implicit conversion from RCReference<Derived> to RCReference<Base>.
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  RCReference(RCReference<U>&& u) : pointer_(u.pointer_) {  // NOLINT
+    u.pointer_ = nullptr;
+  }
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  RCReference(const RCReference<U>& u) : pointer_(u.pointer_) {  // NOLINT
+    if (pointer_) pointer_->AddRef();
+  }
+
+  ~RCReference() {
+    if (pointer_ != nullptr) pointer_->DropRef();
+  }
+
+  void reset(T* pointer = nullptr) {
+    if (pointer_ != nullptr) pointer_->DropRef();
+    pointer_ = pointer;
+  }
+
+  T* release() {
+    T* tmp = pointer_;
+    pointer_ = nullptr;
+    return tmp;
+  }
+
+  T& operator*() const {
+    assert(pointer_ && "null RCReference");
+    return *pointer_;
+  }
+
+  T* operator->() const {
+    assert(pointer_ && "null RCReference");
+    return pointer_;
+  }
+
+  // Return a raw pointer.
+  T* get() const { return pointer_; }
+
+  // Make an explicit copy of this RCReference, increasing the refcount by one.
+  [[deprecated("Use copy constructor instead.")]] RCReference CopyRef() const;
+
+  explicit operator bool() const { return pointer_ != nullptr; }
+
+  void swap(RCReference& other) {
+    using std::swap;
+    swap(pointer_, other.pointer_);
+  }
+
+  bool operator==(const RCReference& ref) const {
+    return pointer_ == ref.pointer_;
+  }
+  bool operator!=(const RCReference& ref) const {
+    return pointer_ != ref.pointer_;
+  }
+
+  friend bool operator==(const RCReference& ref, std::nullptr_t) {
+    return ref.pointer_ == nullptr;
+  }
+  friend bool operator==(std::nullptr_t, const RCReference& ref) {
+    return ref.pointer_ == nullptr;
+  }
+  friend bool operator!=(const RCReference& ref, std::nullptr_t) {
+    return ref.pointer_ != nullptr;
+  }
+  friend bool operator!=(std::nullptr_t, const RCReference& ref) {
+    return ref.pointer_ != nullptr;
+  }
+
+  template <typename R>
+  friend RCReference<R> FormRef(R*);
+  template <typename R>
+  friend RCReference<R> TakeRef(R*);
+
+ private:
+  T* pointer_;
+
+  template <typename R>
+  friend class RCReference;
+};
+
+// Add a new reference to the specified pointer.
+template <typename T>
+RCReference<T> FormRef(T* pointer) {
+  RCReference<T> ref;
+  ref.pointer_ = pointer;
+  pointer->AddRef();
+  return ref;
+}
+
+// Return an RCReference for the specified object and *takes ownership* of a
+// +1 reference.  When destroyed, this will drop the reference.
+template <typename T>
+RCReference<T> TakeRef(T* pointer) {
+  RCReference<T> ref;
+  ref.pointer_ = pointer;
+  return ref;
+}
+
+template <typename T>
+RCReference<T> RCReference<T>::CopyRef() const {
+  if (!pointer_) return RCReference();
+  return FormRef(get());
+}
+
+// Create a new reference counted object, similar to std::make_shared.
+template <typename T, typename... Args>
+RCReference<T> MakeRef(Args&&... args) {
+  auto t = new T(std::forward<Args>(args)...);
+  return TakeRef(t);
+}
+// For ADL style swap.
+template <typename T>
+void swap(RCReference<T>& a, RCReference<T>& b) {
+  a.swap(b);
+}
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_CONCURRENCY_REF_COUNT_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/cuda/cublas.inc

@@ -0,0 +1,736 @@
+  "cublasAlloc",
+  "cublasAsumEx",
+  "cublasAsumEx_64",
+  "cublasAxpyEx",
+  "cublasAxpyEx_64",
+  "cublasCaxpy",
+  "cublasCaxpy_v2",
+  "cublasCaxpy_v2_64",
+  "cublasCbdmm",
+  "cublasCcopy",
+  "cublasCcopy_v2",
+  "cublasCcopy_v2_64",
+  "cublasCdgmm",
+  "cublasCdgmm_64",
+  "cublasCdotc",
+  "cublasCdotc_v2",
+  "cublasCdotc_v2_64",
+  "cublasCdotu",
+  "cublasCdotu_v2",
+  "cublasCdotu_v2_64",
+  "cublasCgbmv",
+  "cublasCgbmv_v2",
+  "cublasCgbmv_v2_64",
+  "cublasCgeam",
+  "cublasCgeam_64",
+  "cublasCgelsBatched",
+  "cublasCgemm",
+  "cublasCgemm3m",
+  "cublasCgemm3mBatched",
+  "cublasCgemm3mBatched_64",
+  "cublasCgemm3mEx",
+  "cublasCgemm3mEx_64",
+  "cublasCgemm3mStridedBatched",
+  "cublasCgemm3mStridedBatched_64",
+  "cublasCgemm3m_64",
+  "cublasCgemmBatched",
+  "cublasCgemmBatched_64",
+  "cublasCgemmEx",
+  "cublasCgemmEx_64",
+  "cublasCgemmStridedBatched",
+  "cublasCgemmStridedBatched_64",
+  "cublasCgemm_v2",
+  "cublasCgemm_v2_64",
+  "cublasCgemv",
+  "cublasCgemvBatched",
+  "cublasCgemvBatched_64",
+  "cublasCgemvStridedBatched",
+  "cublasCgemvStridedBatched_64",
+  "cublasCgemv_v2",
+  "cublasCgemv_v2_64",
+  "cublasCgeqrfBatched",
+  "cublasCgerc",
+  "cublasCgerc_v2",
+  "cublasCgerc_v2_64",
+  "cublasCgeru",
+  "cublasCgeru_v2",
+  "cublasCgeru_v2_64",
+  "cublasCgetrfBatched",
+  "cublasCgetriBatched",
+  "cublasCgetrsBatched",
+  "cublasChbmv",
+  "cublasChbmv_v2",
+  "cublasChbmv_v2_64",
+  "cublasChemm",
+  "cublasChemm_v2",
+  "cublasChemm_v2_64",
+  "cublasChemv",
+  "cublasChemv_v2",
+  "cublasChemv_v2_64",
+  "cublasCher",
+  "cublasCher2",
+  "cublasCher2_v2",
+  "cublasCher2_v2_64",
+  "cublasCher2k",
+  "cublasCher2k_v2",
+  "cublasCher2k_v2_64",
+  "cublasCher_v2",
+  "cublasCher_v2_64",
+  "cublasCherk",
+  "cublasCherk3mEx",
+  "cublasCherk3mEx_64",
+  "cublasCherkEx",
+  "cublasCherkEx_64",
+  "cublasCherk_v2",
+  "cublasCherk_v2_64",
+  "cublasCherkx",
+  "cublasCherkx_64",
+  "cublasChpmv",
+  "cublasChpmv_v2",
+  "cublasChpmv_v2_64",
+  "cublasChpr",
+  "cublasChpr2",
+  "cublasChpr2_v2",
+  "cublasChpr2_v2_64",
+  "cublasChpr_v2",
+  "cublasChpr_v2_64",
+  "cublasCmatinvBatched",
+  "cublasCopyEx",
+  "cublasCopyEx_64",
+  "cublasCreate_v2",
+  "cublasCrot",
+  "cublasCrot_v2",
+  "cublasCrot_v2_64",
+  "cublasCrotg",
+  "cublasCrotg_v2",
+  "cublasCscal",
+  "cublasCscal_v2",
+  "cublasCscal_v2_64",
+  "cublasCsrot",
+  "cublasCsrot_v2",
+  "cublasCsrot_v2_64",
+  "cublasCsscal",
+  "cublasCsscal_v2",
+  "cublasCsscal_v2_64",
+  "cublasCswap",
+  "cublasCswap_v2",
+  "cublasCswap_v2_64",
+  "cublasCsymm",
+  "cublasCsymm_v2",
+  "cublasCsymm_v2_64",
+  "cublasCsymv_v2",
+  "cublasCsymv_v2_64",
+  "cublasCsyr2_v2",
+  "cublasCsyr2_v2_64",
+  "cublasCsyr2k",
+  "cublasCsyr2k_v2",
+  "cublasCsyr2k_v2_64",
+  "cublasCsyr_v2",
+  "cublasCsyr_v2_64",
+  "cublasCsyrk",
+  "cublasCsyrk3mEx",
+  "cublasCsyrk3mEx_64",
+  "cublasCsyrkEx",
+  "cublasCsyrkEx_64",
+  "cublasCsyrk_v2",
+  "cublasCsyrk_v2_64",
+  "cublasCsyrkx",
+  "cublasCsyrkx_64",
+  "cublasCtbmv",
+  "cublasCtbmv_v2",
+  "cublasCtbmv_v2_64",
+  "cublasCtbsv",
+  "cublasCtbsv_v2",
+  "cublasCtbsv_v2_64",
+  "cublasCtpmv",
+  "cublasCtpmv_v2",
+  "cublasCtpmv_v2_64",
+  "cublasCtpsv",
+  "cublasCtpsv_v2",
+  "cublasCtpsv_v2_64",
+  "cublasCtpttr",
+  "cublasCtrmm",
+  "cublasCtrmm_v2",
+  "cublasCtrmm_v2_64",
+  "cublasCtrmv",
+  "cublasCtrmv_v2",
+  "cublasCtrmv_v2_64",
+  "cublasCtrsm",
+  "cublasCtrsmBatched",
+  "cublasCtrsmBatched_64",
+  "cublasCtrsm_v2",
+  "cublasCtrsm_v2_64",
+  "cublasCtrsv",
+  "cublasCtrsv_v2",
+  "cublasCtrsv_v2_64",
+  "cublasCtrttp",
+  "cublasDasum",
+  "cublasDasum_v2",
+  "cublasDasum_v2_64",
+  "cublasDaxpy",
+  "cublasDaxpy_v2",
+  "cublasDaxpy_v2_64",
+  "cublasDbdmm",
+  "cublasDcopy",
+  "cublasDcopy_v2",
+  "cublasDcopy_v2_64",
+  "cublasDdgmm",
+  "cublasDdgmm_64",
+  "cublasDdot",
+  "cublasDdot_v2",
+  "cublasDdot_v2_64",
+  "cublasDestroy_v2",
+  "cublasDgbmv",
+  "cublasDgbmv_v2",
+  "cublasDgbmv_v2_64",
+  "cublasDgeam",
+  "cublasDgeam_64",
+  "cublasDgelsBatched",
+  "cublasDgemm",
+  "cublasDgemmBatched",
+  "cublasDgemmBatched_64",
+  "cublasDgemmStridedBatched",
+  "cublasDgemmStridedBatched_64",
+  "cublasDgemm_v2",
+  "cublasDgemm_v2_64",
+  "cublasDgemv",
+  "cublasDgemvBatched",
+  "cublasDgemvBatched_64",
+  "cublasDgemvStridedBatched",
+  "cublasDgemvStridedBatched_64",
+  "cublasDgemv_v2",
+  "cublasDgemv_v2_64",
+  "cublasDgeqrfBatched",
+  "cublasDger",
+  "cublasDger_v2",
+  "cublasDger_v2_64",
+  "cublasDgetrfBatched",
+  "cublasDgetriBatched",
+  "cublasDgetrsBatched",
+  "cublasDmatinvBatched",
+  "cublasDnrm2",
+  "cublasDnrm2_v2",
+  "cublasDnrm2_v2_64",
+  "cublasDotEx",
+  "cublasDotEx_64",
+  "cublasDotcEx",
+  "cublasDotcEx_64",
+  "cublasDrot",
+  "cublasDrot_v2",
+  "cublasDrot_v2_64",
+  "cublasDrotg",
+  "cublasDrotg_v2",
+  "cublasDrotm",
+  "cublasDrotm_v2",
+  "cublasDrotm_v2_64",
+  "cublasDrotmg",
+  "cublasDrotmg_v2",
+  "cublasDsbmv",
+  "cublasDsbmv_v2",
+  "cublasDsbmv_v2_64",
+  "cublasDscal",
+  "cublasDscal_v2",
+  "cublasDscal_v2_64",
+  "cublasDspmv",
+  "cublasDspmv_v2",
+  "cublasDspmv_v2_64",
+  "cublasDspr",
+  "cublasDspr2",
+  "cublasDspr2_v2",
+  "cublasDspr2_v2_64",
+  "cublasDspr_v2",
+  "cublasDspr_v2_64",
+  "cublasDswap",
+  "cublasDswap_v2",
+  "cublasDswap_v2_64",
+  "cublasDsymm",
+  "cublasDsymm_v2",
+  "cublasDsymm_v2_64",
+  "cublasDsymv",
+  "cublasDsymv_v2",
+  "cublasDsymv_v2_64",
+  "cublasDsyr",
+  "cublasDsyr2",
+  "cublasDsyr2_v2",
+  "cublasDsyr2_v2_64",
+  "cublasDsyr2k",
+  "cublasDsyr2k_v2",
+  "cublasDsyr2k_v2_64",
+  "cublasDsyr_v2",
+  "cublasDsyr_v2_64",
+  "cublasDsyrk",
+  "cublasDsyrk_v2",
+  "cublasDsyrk_v2_64",
+  "cublasDsyrkx",
+  "cublasDsyrkx_64",
+  "cublasDtbmv",
+  "cublasDtbmv_v2",
+  "cublasDtbmv_v2_64",
+  "cublasDtbsv",
+  "cublasDtbsv_v2",
+  "cublasDtbsv_v2_64",
+  "cublasDtpmv",
+  "cublasDtpmv_v2",
+  "cublasDtpmv_v2_64",
+  "cublasDtpsv",
+  "cublasDtpsv_v2",
+  "cublasDtpsv_v2_64",
+  "cublasDtpttr",
+  "cublasDtrmm",
+  "cublasDtrmm_v2",
+  "cublasDtrmm_v2_64",
+  "cublasDtrmv",
+  "cublasDtrmv_v2",
+  "cublasDtrmv_v2_64",
+  "cublasDtrsm",
+  "cublasDtrsmBatched",
+  "cublasDtrsmBatched_64",
+  "cublasDtrsm_v2",
+  "cublasDtrsm_v2_64",
+  "cublasDtrsv",
+  "cublasDtrsv_v2",
+  "cublasDtrsv_v2_64",
+  "cublasDtrttp",
+  "cublasDzasum",
+  "cublasDzasum_v2",
+  "cublasDzasum_v2_64",
+  "cublasDznrm2",
+  "cublasDznrm2_v2",
+  "cublasDznrm2_v2_64",
+  "cublasFree",
+  "cublasGemmBatchedEx",
+  "cublasGemmBatchedEx_64",
+  "cublasGemmEx",
+  "cublasGemmEx_64",
+  "cublasGemmStridedBatchedEx",
+  "cublasGemmStridedBatchedEx_64",
+  "cublasGetAtomicsMode",
+  "cublasGetBackdoor",
+  "cublasGetCudartVersion",
+  "cublasGetError",
+  "cublasGetLoggerCallback",
+  "cublasGetMathMode",
+  "cublasGetMatrix",
+  "cublasGetMatrixAsync",
+  "cublasGetMatrixAsync_64",
+  "cublasGetMatrix_64",
+  "cublasGetPointerMode_v2",
+  "cublasGetProperty",
+  "cublasGetSmCountTarget",
+  "cublasGetStatusName",
+  "cublasGetStatusString",
+  "cublasGetStream_v2",
+  "cublasGetVector",
+  "cublasGetVectorAsync",
+  "cublasGetVectorAsync_64",
+  "cublasGetVector_64",
+  "cublasGetVersion",
+  "cublasGetVersion_v2",
+  "cublasHSHgemvBatched",
+  "cublasHSHgemvBatched_64",
+  "cublasHSHgemvStridedBatched",
+  "cublasHSHgemvStridedBatched_64",
+  "cublasHSSgemvBatched",
+  "cublasHSSgemvBatched_64",
+  "cublasHSSgemvStridedBatched",
+  "cublasHSSgemvStridedBatched_64",
+  "cublasHgemm",
+  "cublasHgemmBatched",
+  "cublasHgemmBatched_64",
+  "cublasHgemmStridedBatched",
+  "cublasHgemmStridedBatched_64",
+  "cublasHgemm_64",
+  "cublasIamaxEx",
+  "cublasIamaxEx_64",
+  "cublasIaminEx",
+  "cublasIaminEx_64",
+  "cublasIcamax",
+  "cublasIcamax_v2",
+  "cublasIcamax_v2_64",
+  "cublasIcamin",
+  "cublasIcamin_v2",
+  "cublasIcamin_v2_64",
+  "cublasIdamax",
+  "cublasIdamax_v2",
+  "cublasIdamax_v2_64",
+  "cublasIdamin",
+  "cublasIdamin_v2",
+  "cublasIdamin_v2_64",
+  "cublasInit",
+  "cublasIsamax",
+  "cublasIsamax_v2",
+  "cublasIsamax_v2_64",
+  "cublasIsamin",
+  "cublasIsamin_v2",
+  "cublasIsamin_v2_64",
+  "cublasIzamax",
+  "cublasIzamax_v2",
+  "cublasIzamax_v2_64",
+  "cublasIzamin",
+  "cublasIzamin_v2",
+  "cublasIzamin_v2_64",
+  "cublasLoggerConfigure",
+  "cublasNrm2Ex",
+  "cublasNrm2Ex_64",
+  "cublasRotEx",
+  "cublasRotEx_64",
+  "cublasRotgEx",
+  "cublasRotmEx",
+  "cublasRotmEx_64",
+  "cublasRotmgEx",
+  "cublasSasum",
+  "cublasSasum_v2",
+  "cublasSasum_v2_64",
+  "cublasSaxpy",
+  "cublasSaxpy_v2",
+  "cublasSaxpy_v2_64",
+  "cublasSbdmm",
+  "cublasScalEx",
+  "cublasScalEx_64",
+  "cublasScasum",
+  "cublasScasum_v2",
+  "cublasScasum_v2_64",
+  "cublasScnrm2",
+  "cublasScnrm2_v2",
+  "cublasScnrm2_v2_64",
+  "cublasScopy",
+  "cublasScopy_v2",
+  "cublasScopy_v2_64",
+  "cublasSdgmm",
+  "cublasSdgmm_64",
+  "cublasSdot",
+  "cublasSdot_v2",
+  "cublasSdot_v2_64",
+  "cublasSetAtomicsMode",
+  "cublasSetBackdoor",
+  "cublasSetBackdoorEx",
+  "cublasSetKernelStream",
+  "cublasSetLoggerCallback",
+  "cublasSetMathMode",
+  "cublasSetMatrix",
+  "cublasSetMatrixAsync",
+  "cublasSetMatrixAsync_64",
+  "cublasSetMatrix_64",
+  "cublasSetPointerMode_v2",
+  "cublasSetSmCountTarget",
+  "cublasSetStream_v2",
+  "cublasSetVector",
+  "cublasSetVectorAsync",
+  "cublasSetVectorAsync_64",
+  "cublasSetVector_64",
+  "cublasSetWorkspace_v2",
+  "cublasSgbmv",
+  "cublasSgbmv_v2",
+  "cublasSgbmv_v2_64",
+  "cublasSgeam",
+  "cublasSgeam_64",
+  "cublasSgelsBatched",
+  "cublasSgemm",
+  "cublasSgemmBatched",
+  "cublasSgemmBatched_64",
+  "cublasSgemmEx",
+  "cublasSgemmEx_64",
+  "cublasSgemmStridedBatched",
+  "cublasSgemmStridedBatched_64",
+  "cublasSgemm_v2",
+  "cublasSgemm_v2_64",
+  "cublasSgemv",
+  "cublasSgemvBatched",
+  "cublasSgemvBatched_64",
+  "cublasSgemvStridedBatched",
+  "cublasSgemvStridedBatched_64",
+  "cublasSgemv_v2",
+  "cublasSgemv_v2_64",
+  "cublasSgeqrfBatched",
+  "cublasSger",
+  "cublasSger_v2",
+  "cublasSger_v2_64",
+  "cublasSgetrfBatched",
+  "cublasSgetriBatched",
+  "cublasSgetrsBatched",
+  "cublasShutdown",
+  "cublasSmatinvBatched",
+  "cublasSnrm2",
+  "cublasSnrm2_v2",
+  "cublasSnrm2_v2_64",
+  "cublasSrot",
+  "cublasSrot_v2",
+  "cublasSrot_v2_64",
+  "cublasSrotg",
+  "cublasSrotg_v2",
+  "cublasSrotm",
+  "cublasSrotm_v2",
+  "cublasSrotm_v2_64",
+  "cublasSrotmg",
+  "cublasSrotmg_v2",
+  "cublasSsbmv",
+  "cublasSsbmv_v2",
+  "cublasSsbmv_v2_64",
+  "cublasSscal",
+  "cublasSscal_v2",
+  "cublasSscal_v2_64",
+  "cublasSspmv",
+  "cublasSspmv_v2",
+  "cublasSspmv_v2_64",
+  "cublasSspr",
+  "cublasSspr2",
+  "cublasSspr2_v2",
+  "cublasSspr2_v2_64",
+  "cublasSspr_v2",
+  "cublasSspr_v2_64",
+  "cublasSswap",
+  "cublasSswap_v2",
+  "cublasSswap_v2_64",
+  "cublasSsymm",
+  "cublasSsymm_v2",
+  "cublasSsymm_v2_64",
+  "cublasSsymv",
+  "cublasSsymv_v2",
+  "cublasSsymv_v2_64",
+  "cublasSsyr",
+  "cublasSsyr2",
+  "cublasSsyr2_v2",
+  "cublasSsyr2_v2_64",
+  "cublasSsyr2k",
+  "cublasSsyr2k_v2",
+  "cublasSsyr2k_v2_64",
+  "cublasSsyr_v2",
+  "cublasSsyr_v2_64",
+  "cublasSsyrk",
+  "cublasSsyrk_v2",
+  "cublasSsyrk_v2_64",
+  "cublasSsyrkx",
+  "cublasSsyrkx_64",
+  "cublasStbmv",
+  "cublasStbmv_v2",
+  "cublasStbmv_v2_64",
+  "cublasStbsv",
+  "cublasStbsv_v2",
+  "cublasStbsv_v2_64",
+  "cublasStpmv",
+  "cublasStpmv_v2",
+  "cublasStpmv_v2_64",
+  "cublasStpsv",
+  "cublasStpsv_v2",
+  "cublasStpsv_v2_64",
+  "cublasStpttr",
+  "cublasStrmm",
+  "cublasStrmm_v2",
+  "cublasStrmm_v2_64",
+  "cublasStrmv",
+  "cublasStrmv_v2",
+  "cublasStrmv_v2_64",
+  "cublasStrsm",
+  "cublasStrsmBatched",
+  "cublasStrsmBatched_64",
+  "cublasStrsm_v2",
+  "cublasStrsm_v2_64",
+  "cublasStrsv",
+  "cublasStrsv_v2",
+  "cublasStrsv_v2_64",
+  "cublasStrttp",
+  "cublasSwapEx",
+  "cublasSwapEx_64",
+  "cublasTSSgemvBatched",
+  "cublasTSSgemvBatched_64",
+  "cublasTSSgemvStridedBatched",
+  "cublasTSSgemvStridedBatched_64",
+  "cublasTSTgemvBatched",
+  "cublasTSTgemvBatched_64",
+  "cublasTSTgemvStridedBatched",
+  "cublasTSTgemvStridedBatched_64",
+  "cublasUint8gemmBias",
+  "cublasXerbla",
+  "cublasXtCgemm",
+  "cublasXtChemm",
+  "cublasXtCher2k",
+  "cublasXtCherk",
+  "cublasXtCherkx",
+  "cublasXtCreate",
+  "cublasXtCspmm",
+  "cublasXtCsymm",
+  "cublasXtCsyr2k",
+  "cublasXtCsyrk",
+  "cublasXtCsyrkx",
+  "cublasXtCtrmm",
+  "cublasXtCtrsm",
+  "cublasXtDestroy",
+  "cublasXtDeviceSelect",
+  "cublasXtDgemm",
+  "cublasXtDspmm",
+  "cublasXtDsymm",
+  "cublasXtDsyr2k",
+  "cublasXtDsyrk",
+  "cublasXtDsyrkx",
+  "cublasXtDtrmm",
+  "cublasXtDtrsm",
+  "cublasXtGetBlockDim",
+  "cublasXtGetNumBoards",
+  "cublasXtGetPinningMemMode",
+  "cublasXtMaxBoards",
+  "cublasXtSetBlockDim",
+  "cublasXtSetCpuRatio",
+  "cublasXtSetCpuRoutine",
+  "cublasXtSetPinningMemMode",
+  "cublasXtSgemm",
+  "cublasXtSspmm",
+  "cublasXtSsymm",
+  "cublasXtSsyr2k",
+  "cublasXtSsyrk",
+  "cublasXtSsyrkx",
+  "cublasXtStrmm",
+  "cublasXtStrsm",
+  "cublasXtZgemm",
+  "cublasXtZhemm",
+  "cublasXtZher2k",
+  "cublasXtZherk",
+  "cublasXtZherkx",
+  "cublasXtZspmm",
+  "cublasXtZsymm",
+  "cublasXtZsyr2k",
+  "cublasXtZsyrk",
+  "cublasXtZsyrkx",
+  "cublasXtZtrmm",
+  "cublasXtZtrsm",
+  "cublasZaxpy",
+  "cublasZaxpy_v2",
+  "cublasZaxpy_v2_64",
+  "cublasZbdmm",
+  "cublasZcopy",
+  "cublasZcopy_v2",
+  "cublasZcopy_v2_64",
+  "cublasZdgmm",
+  "cublasZdgmm_64",
+  "cublasZdotc",
+  "cublasZdotc_v2",
+  "cublasZdotc_v2_64",
+  "cublasZdotu",
+  "cublasZdotu_v2",
+  "cublasZdotu_v2_64",
+  "cublasZdrot",
+  "cublasZdrot_v2",
+  "cublasZdrot_v2_64",
+  "cublasZdscal",
+  "cublasZdscal_v2",
+  "cublasZdscal_v2_64",
+  "cublasZgbmv",
+  "cublasZgbmv_v2",
+  "cublasZgbmv_v2_64",
+  "cublasZgeam",
+  "cublasZgeam_64",
+  "cublasZgelsBatched",
+  "cublasZgemm",
+  "cublasZgemm3m",
+  "cublasZgemm3m_64",
+  "cublasZgemmBatched",
+  "cublasZgemmBatched_64",
+  "cublasZgemmStridedBatched",
+  "cublasZgemmStridedBatched_64",
+  "cublasZgemm_v2",
+  "cublasZgemm_v2_64",
+  "cublasZgemv",
+  "cublasZgemvBatched",
+  "cublasZgemvBatched_64",
+  "cublasZgemvStridedBatched",
+  "cublasZgemvStridedBatched_64",
+  "cublasZgemv_v2",
+  "cublasZgemv_v2_64",
+  "cublasZgeqrfBatched",
+  "cublasZgerc",
+  "cublasZgerc_v2",
+  "cublasZgerc_v2_64",
+  "cublasZgeru",
+  "cublasZgeru_v2",
+  "cublasZgeru_v2_64",
+  "cublasZgetrfBatched",
+  "cublasZgetriBatched",
+  "cublasZgetrsBatched",
+  "cublasZhbmv",
+  "cublasZhbmv_v2",
+  "cublasZhbmv_v2_64",
+  "cublasZhemm",
+  "cublasZhemm_v2",
+  "cublasZhemm_v2_64",
+  "cublasZhemv",
+  "cublasZhemv_v2",
+  "cublasZhemv_v2_64",
+  "cublasZher",
+  "cublasZher2",
+  "cublasZher2_v2",
+  "cublasZher2_v2_64",
+  "cublasZher2k",
+  "cublasZher2k_v2",
+  "cublasZher2k_v2_64",
+  "cublasZher_v2",
+  "cublasZher_v2_64",
+  "cublasZherk",
+  "cublasZherk_v2",
+  "cublasZherk_v2_64",
+  "cublasZherkx",
+  "cublasZherkx_64",
+  "cublasZhpmv",
+  "cublasZhpmv_v2",
+  "cublasZhpmv_v2_64",
+  "cublasZhpr",
+  "cublasZhpr2",
+  "cublasZhpr2_v2",
+  "cublasZhpr2_v2_64",
+  "cublasZhpr_v2",
+  "cublasZhpr_v2_64",
+  "cublasZmatinvBatched",
+  "cublasZrot",
+  "cublasZrot_v2",
+  "cublasZrot_v2_64",
+  "cublasZrotg",
+  "cublasZrotg_v2",
+  "cublasZscal",
+  "cublasZscal_v2",
+  "cublasZscal_v2_64",
+  "cublasZswap",
+  "cublasZswap_v2",
+  "cublasZswap_v2_64",
+  "cublasZsymm",
+  "cublasZsymm_v2",
+  "cublasZsymm_v2_64",
+  "cublasZsymv_v2",
+  "cublasZsymv_v2_64",
+  "cublasZsyr2_v2",
+  "cublasZsyr2_v2_64",
+  "cublasZsyr2k",
+  "cublasZsyr2k_v2",
+  "cublasZsyr2k_v2_64",
+  "cublasZsyr_v2",
+  "cublasZsyr_v2_64",
+  "cublasZsyrk",
+  "cublasZsyrk_v2",
+  "cublasZsyrk_v2_64",
+  "cublasZsyrkx",
+  "cublasZsyrkx_64",
+  "cublasZtbmv",
+  "cublasZtbmv_v2",
+  "cublasZtbmv_v2_64",
+  "cublasZtbsv",
+  "cublasZtbsv_v2",
+  "cublasZtbsv_v2_64",
+  "cublasZtpmv",
+  "cublasZtpmv_v2",
+  "cublasZtpmv_v2_64",
+  "cublasZtpsv",
+  "cublasZtpsv_v2",
+  "cublasZtpsv_v2_64",
+  "cublasZtpttr",
+  "cublasZtrmm",
+  "cublasZtrmm_v2",
+  "cublasZtrmm_v2_64",
+  "cublasZtrmv",
+  "cublasZtrmv_v2",
+  "cublasZtrmv_v2_64",
+  "cublasZtrsm",
+  "cublasZtrsmBatched",
+  "cublasZtrsmBatched_64",
+  "cublasZtrsm_v2",
+  "cublasZtrsm_v2_64",
+  "cublasZtrsv",
+  "cublasZtrsv_v2",
+  "cublasZtrsv_v2_64",
+  "cublasZtrttp",

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/cuda/cublasLt.inc

@@ -0,0 +1,291 @@
+  "cublasLtACCMatmul",
+  "cublasLtACCMatmulAlgoCapGetAttribute",
+  "cublasLtACCMatmulAlgoCheck",
+  "cublasLtACCMatmulAlgoGetHeuristic",
+  "cublasLtACCMatmulAlgoGetIds",
+  "cublasLtACCMatmulAlgoInit",
+  "cublasLtAlgoCharacteristicGetAttribute",
+  "cublasLtBIIMatmul",
+  "cublasLtBIIMatmulAlgoCapGetAttribute",
+  "cublasLtBIIMatmulAlgoCheck",
+  "cublasLtBIIMatmulAlgoGetHeuristic",
+  "cublasLtBIIMatmulAlgoGetIds",
+  "cublasLtBIIMatmulAlgoInit",
+  "cublasLtBSBMatmul",
+  "cublasLtBSBMatmulAlgoCapGetAttribute",
+  "cublasLtBSBMatmulAlgoCheck",
+  "cublasLtBSBMatmulAlgoGetHeuristic",
+  "cublasLtBSBMatmulAlgoGetIds",
+  "cublasLtBSBMatmulAlgoInit",
+  "cublasLtBSSMatmul",
+  "cublasLtBSSMatmulAlgoCapGetAttribute",
+  "cublasLtBSSMatmulAlgoCheck",
+  "cublasLtBSSMatmulAlgoGetHeuristic",
+  "cublasLtBSSMatmulAlgoGetIds",
+  "cublasLtBSSMatmulAlgoInit",
+  "cublasLtCCCMatmul",
+  "cublasLtCCCMatmulAlgoCapGetAttribute",
+  "cublasLtCCCMatmulAlgoCheck",
+  "cublasLtCCCMatmulAlgoGetHeuristic",
+  "cublasLtCCCMatmulAlgoGetIds",
+  "cublasLtCCCMatmulAlgoInit",
+  "cublasLtCreate",
+  "cublasLtCtxInit",
+  "cublasLtDDDMatmul",
+  "cublasLtDDDMatmulAlgoCapGetAttribute",
+  "cublasLtDDDMatmulAlgoCheck",
+  "cublasLtDDDMatmulAlgoGetHeuristic",
+  "cublasLtDDDMatmulAlgoGetIds",
+  "cublasLtDDDMatmulAlgoInit",
+  "cublasLtDestroy",
+  "cublasLtE4m3E4m3Fp32Bf16Bf16Matmul",
+  "cublasLtE4m3E4m3Fp32Bf16Bf16MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E4m3Fp32Bf16Bf16MatmulAlgoCheck",
+  "cublasLtE4m3E4m3Fp32Bf16Bf16MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E4m3Fp32Bf16Bf16MatmulAlgoGetIds",
+  "cublasLtE4m3E4m3Fp32Bf16Bf16MatmulAlgoInit",
+  "cublasLtE4m3E4m3Fp32Bf16E4m3Matmul",
+  "cublasLtE4m3E4m3Fp32Bf16E4m3MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E4m3Fp32Bf16E4m3MatmulAlgoCheck",
+  "cublasLtE4m3E4m3Fp32Bf16E4m3MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E4m3Fp32Bf16E4m3MatmulAlgoGetIds",
+  "cublasLtE4m3E4m3Fp32Bf16E4m3MatmulAlgoInit",
+  "cublasLtE4m3E4m3Fp32Fp16E4m3Matmul",
+  "cublasLtE4m3E4m3Fp32Fp16E4m3MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E4m3Fp32Fp16E4m3MatmulAlgoCheck",
+  "cublasLtE4m3E4m3Fp32Fp16E4m3MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E4m3Fp32Fp16E4m3MatmulAlgoGetIds",
+  "cublasLtE4m3E4m3Fp32Fp16E4m3MatmulAlgoInit",
+  "cublasLtE4m3E4m3Fp32Fp16Fp16Matmul",
+  "cublasLtE4m3E4m3Fp32Fp16Fp16MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E4m3Fp32Fp16Fp16MatmulAlgoCheck",
+  "cublasLtE4m3E4m3Fp32Fp16Fp16MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E4m3Fp32Fp16Fp16MatmulAlgoGetIds",
+  "cublasLtE4m3E4m3Fp32Fp16Fp16MatmulAlgoInit",
+  "cublasLtE4m3E4m3Fp32Fp32Fp32Matmul",
+  "cublasLtE4m3E4m3Fp32Fp32Fp32MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E4m3Fp32Fp32Fp32MatmulAlgoCheck",
+  "cublasLtE4m3E4m3Fp32Fp32Fp32MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E4m3Fp32Fp32Fp32MatmulAlgoGetIds",
+  "cublasLtE4m3E4m3Fp32Fp32Fp32MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Bf16Bf16Matmul",
+  "cublasLtE4m3E5m2Fp32Bf16Bf16MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Bf16Bf16MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Bf16Bf16MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Bf16Bf16MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Bf16Bf16MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Bf16E4m3Matmul",
+  "cublasLtE4m3E5m2Fp32Bf16E4m3MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Bf16E4m3MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Bf16E4m3MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Bf16E4m3MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Bf16E4m3MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Bf16E5m2Matmul",
+  "cublasLtE4m3E5m2Fp32Bf16E5m2MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Bf16E5m2MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Bf16E5m2MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Bf16E5m2MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Bf16E5m2MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Fp16E4m3Matmul",
+  "cublasLtE4m3E5m2Fp32Fp16E4m3MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Fp16E4m3MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Fp16E4m3MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Fp16E4m3MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Fp16E4m3MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Fp16E5m2Matmul",
+  "cublasLtE4m3E5m2Fp32Fp16E5m2MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Fp16E5m2MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Fp16E5m2MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Fp16E5m2MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Fp16E5m2MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Fp16Fp16Matmul",
+  "cublasLtE4m3E5m2Fp32Fp16Fp16MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Fp16Fp16MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Fp16Fp16MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Fp16Fp16MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Fp16Fp16MatmulAlgoInit",
+  "cublasLtE4m3E5m2Fp32Fp32Fp32Matmul",
+  "cublasLtE4m3E5m2Fp32Fp32Fp32MatmulAlgoCapGetAttribute",
+  "cublasLtE4m3E5m2Fp32Fp32Fp32MatmulAlgoCheck",
+  "cublasLtE4m3E5m2Fp32Fp32Fp32MatmulAlgoGetHeuristic",
+  "cublasLtE4m3E5m2Fp32Fp32Fp32MatmulAlgoGetIds",
+  "cublasLtE4m3E5m2Fp32Fp32Fp32MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Bf16Bf16Matmul",
+  "cublasLtE5m2E4m3Fp32Bf16Bf16MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Bf16Bf16MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Bf16Bf16MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Bf16Bf16MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Bf16Bf16MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Bf16E4m3Matmul",
+  "cublasLtE5m2E4m3Fp32Bf16E4m3MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Bf16E4m3MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Bf16E4m3MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Bf16E4m3MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Bf16E4m3MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Bf16E5m2Matmul",
+  "cublasLtE5m2E4m3Fp32Bf16E5m2MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Bf16E5m2MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Bf16E5m2MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Bf16E5m2MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Bf16E5m2MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Fp16E4m3Matmul",
+  "cublasLtE5m2E4m3Fp32Fp16E4m3MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Fp16E4m3MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Fp16E4m3MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Fp16E4m3MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Fp16E4m3MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Fp16E5m2Matmul",
+  "cublasLtE5m2E4m3Fp32Fp16E5m2MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Fp16E5m2MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Fp16E5m2MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Fp16E5m2MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Fp16E5m2MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Fp16Fp16Matmul",
+  "cublasLtE5m2E4m3Fp32Fp16Fp16MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Fp16Fp16MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Fp16Fp16MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Fp16Fp16MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Fp16Fp16MatmulAlgoInit",
+  "cublasLtE5m2E4m3Fp32Fp32Fp32Matmul",
+  "cublasLtE5m2E4m3Fp32Fp32Fp32MatmulAlgoCapGetAttribute",
+  "cublasLtE5m2E4m3Fp32Fp32Fp32MatmulAlgoCheck",
+  "cublasLtE5m2E4m3Fp32Fp32Fp32MatmulAlgoGetHeuristic",
+  "cublasLtE5m2E4m3Fp32Fp32Fp32MatmulAlgoGetIds",
+  "cublasLtE5m2E4m3Fp32Fp32Fp32MatmulAlgoInit",
+  "cublasLtGetCudartVersion",
+  "cublasLtGetProperty",
+  "cublasLtGetStatusName",
+  "cublasLtGetStatusString",
+  "cublasLtGetVersion",
+  "cublasLtHHHMatmul",
+  "cublasLtHHHMatmulAlgoCapGetAttribute",
+  "cublasLtHHHMatmulAlgoCheck",
+  "cublasLtHHHMatmulAlgoGetHeuristic",
+  "cublasLtHHHMatmulAlgoGetIds",
+  "cublasLtHHHMatmulAlgoInit",
+  "cublasLtHSHMatmul",
+  "cublasLtHSHMatmulAlgoCapGetAttribute",
+  "cublasLtHSHMatmulAlgoCheck",
+  "cublasLtHSHMatmulAlgoGetHeuristic",
+  "cublasLtHSHMatmulAlgoGetIds",
+  "cublasLtHSHMatmulAlgoInit",
+  "cublasLtHSSMatmul",
+  "cublasLtHSSMatmulAlgoCapGetAttribute",
+  "cublasLtHSSMatmulAlgoCheck",
+  "cublasLtHSSMatmulAlgoGetHeuristic",
+  "cublasLtHSSMatmulAlgoGetIds",
+  "cublasLtHSSMatmulAlgoInit",
+  "cublasLtHeuristicLutSerializeEntry",
+  "cublasLtHeuristicsCacheGetCapacity",
+  "cublasLtHeuristicsCacheSetCapacity",
+  "cublasLtKCCMatmul",
+  "cublasLtKCCMatmulAlgoCapGetAttribute",
+  "cublasLtKCCMatmulAlgoCheck",
+  "cublasLtKCCMatmulAlgoGetHeuristic",
+  "cublasLtKCCMatmulAlgoGetIds",
+  "cublasLtKCCMatmulAlgoInit",
+  "cublasLtKCKMatmul",
+  "cublasLtKCKMatmulAlgoCapGetAttribute",
+  "cublasLtKCKMatmulAlgoCheck",
+  "cublasLtKCKMatmulAlgoGetHeuristic",
+  "cublasLtKCKMatmulAlgoGetIds",
+  "cublasLtKCKMatmulAlgoInit",
+  "cublasLtLegacyGemmACC",
+  "cublasLtLegacyGemmBII",
+  "cublasLtLegacyGemmBSS",
+  "cublasLtLegacyGemmCCC",
+  "cublasLtLegacyGemmDDD",
+  "cublasLtLegacyGemmHHH",
+  "cublasLtLegacyGemmHSH",
+  "cublasLtLegacyGemmHSS",
+  "cublasLtLegacyGemmSSS",
+  "cublasLtLegacyGemmTSS",
+  "cublasLtLegacyGemmTST",
+  "cublasLtLegacyGemmUtilizationCCC",
+  "cublasLtLegacyGemmUtilizationDDD",
+  "cublasLtLegacyGemmUtilizationZZZ",
+  "cublasLtLegacyGemmZZZ",
+  "cublasLtLoggerForceDisable",
+  "cublasLtLoggerOpenFile",
+  "cublasLtLoggerSetCallback",
+  "cublasLtLoggerSetFile",
+  "cublasLtLoggerSetLevel",
+  "cublasLtLoggerSetMask",
+  "cublasLtMatmul",
+  "cublasLtMatmulAlgoCapGetAttribute",
+  "cublasLtMatmulAlgoCheck",
+  "cublasLtMatmulAlgoConfigGetAttribute",
+  "cublasLtMatmulAlgoConfigGetAttributeRange",
+  "cublasLtMatmulAlgoConfigSetAttribute",
+  "cublasLtMatmulAlgoGetHeuristic",
+  "cublasLtMatmulAlgoGetIds",
+  "cublasLtMatmulAlgoInit",
+  "cublasLtMatmulDescCreate",
+  "cublasLtMatmulDescDestroy",
+  "cublasLtMatmulDescGetAttribute",
+  "cublasLtMatmulDescInit_internal",
+  "cublasLtMatmulDescSetAttribute",
+  "cublasLtMatmulPreferenceCreate",
+  "cublasLtMatmulPreferenceDestroy",
+  "cublasLtMatmulPreferenceGetAttribute",
+  "cublasLtMatmulPreferenceInit_internal",
+  "cublasLtMatmulPreferenceSetAttribute",
+  "cublasLtMatrixLayoutCreate",
+  "cublasLtMatrixLayoutDestroy",
+  "cublasLtMatrixLayoutGetAttribute",
+  "cublasLtMatrixLayoutInit_internal",
+  "cublasLtMatrixLayoutSetAttribute",
+  "cublasLtMatrixTransform",
+  "cublasLtMatrixTransformDescCreate",
+  "cublasLtMatrixTransformDescDestroy",
+  "cublasLtMatrixTransformDescGetAttribute",
+  "cublasLtMatrixTransformDescInit_internal",
+  "cublasLtMatrixTransformDescSetAttribute",
+  "cublasLtSSSMatmul",
+  "cublasLtSSSMatmulAlgoCapGetAttribute",
+  "cublasLtSSSMatmulAlgoCheck",
+  "cublasLtSSSMatmulAlgoGetHeuristic",
+  "cublasLtSSSMatmulAlgoGetIds",
+  "cublasLtSSSMatmulAlgoInit",
+  "cublasLtShutdownCtx",
+  "cublasLtTSSMatmul",
+  "cublasLtTSSMatmulAlgoCapGetAttribute",
+  "cublasLtTSSMatmulAlgoCheck",
+  "cublasLtTSSMatmulAlgoGetHeuristic",
+  "cublasLtTSSMatmulAlgoGetIds",
+  "cublasLtTSSMatmulAlgoInit",
+  "cublasLtTSTMatmul",
+  "cublasLtTSTMatmulAlgoCapGetAttribute",
+  "cublasLtTSTMatmulAlgoCheck",
+  "cublasLtTSTMatmulAlgoGetHeuristic",
+  "cublasLtTSTMatmulAlgoGetIds",
+  "cublasLtTSTMatmulAlgoInit",
+  "cublasLtVCCMatmul",
+  "cublasLtVCCMatmulAlgoCapGetAttribute",
+  "cublasLtVCCMatmulAlgoCheck",
+  "cublasLtVCCMatmulAlgoGetHeuristic",
+  "cublasLtVCCMatmulAlgoGetIds",
+  "cublasLtVCCMatmulAlgoInit",
+  "cublasLtVCVMatmul",
+  "cublasLtVCVMatmulAlgoCapGetAttribute",
+  "cublasLtVCVMatmulAlgoCheck",
+  "cublasLtVCVMatmulAlgoGetHeuristic",
+  "cublasLtVCVMatmulAlgoGetIds",
+  "cublasLtVCVMatmulAlgoInit",
+  "cublasLtZZZMatmul",
+  "cublasLtZZZMatmulAlgoCapGetAttribute",
+  "cublasLtZZZMatmulAlgoCheck",
+  "cublasLtZZZMatmulAlgoGetHeuristic",
+  "cublasLtZZZMatmulAlgoGetIds",
+  "cublasLtZZZMatmulAlgoInit",
+  "cublasLt_for_cublas_BII",
+  "cublasLt_for_cublas_BSS",
+  "cublasLt_for_cublas_CCC",
+  "cublasLt_for_cublas_DDD",
+  "cublasLt_for_cublas_HHH",
+  "cublasLt_for_cublas_HSH",
+  "cublasLt_for_cublas_HSS",
+  "cublasLt_for_cublas_SSS",
+  "cublasLt_for_cublas_TSS",
+  "cublasLt_for_cublas_TST",
+  "cublasLt_for_cublas_ZZZ",

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/cuda/cufft.inc

@@ -0,0 +1,55 @@
+  "cufftCreate",
+  "cufftDebug",
+  "cufftDestroy",
+  "cufftEstimate1d",
+  "cufftEstimate2d",
+  "cufftEstimate3d",
+  "cufftEstimateMany",
+  "cufftExecC2C",
+  "cufftExecC2R",
+  "cufftExecD2Z",
+  "cufftExecR2C",
+  "cufftExecZ2D",
+  "cufftExecZ2Z",
+  "cufftGetProperty",
+  "cufftGetSize",
+  "cufftGetSize1d",
+  "cufftGetSize2d",
+  "cufftGetSize3d",
+  "cufftGetSizeMany",
+  "cufftGetSizeMany64",
+  "cufftGetVersion",
+  "cufftMakePlan1d",
+  "cufftMakePlan2d",
+  "cufftMakePlan3d",
+  "cufftMakePlanMany",
+  "cufftMakePlanMany64",
+  "cufftPlan1d",
+  "cufftPlan2d",
+  "cufftPlan3d",
+  "cufftPlanMany",
+  "cufftSetAutoAllocation",
+  "cufftSetStream",
+  "cufftSetWorkArea",
+  "cufftXtClearCallback",
+  "cufftXtExec",
+  "cufftXtExecDescriptor",
+  "cufftXtExecDescriptorC2C",
+  "cufftXtExecDescriptorC2R",
+  "cufftXtExecDescriptorD2Z",
+  "cufftXtExecDescriptorR2C",
+  "cufftXtExecDescriptorZ2D",
+  "cufftXtExecDescriptorZ2Z",
+  "cufftXtFree",
+  "cufftXtGetSizeMany",
+  "cufftXtMakePlanGuru64",
+  "cufftXtMakePlanMany",
+  "cufftXtMalloc",
+  "cufftXtMemcpy",
+  "cufftXtQueryPlan",
+  "cufftXtSetCallback",
+  "cufftXtSetCallbackSharedSize",
+  "cufftXtSetDistribution",
+  "cufftXtSetGPUs",
+  "cufftXtSetWorkArea",
+  "cufftXtSetWorkAreaPolicy",

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/cuda/cupti.inc

@@ -0,0 +1,148 @@
+  "InitializeInjectionNvtx",
+  "InitializeInjectionNvtx2",
+  "cuptiActivityConfigurePCSampling",
+  "cuptiActivityConfigureUnifiedMemoryCounter",
+  "cuptiActivityDisable",
+  "cuptiActivityDisableContext",
+  "cuptiActivityEnable",
+  "cuptiActivityEnableAndDump",
+  "cuptiActivityEnableBufferSummary",
+  "cuptiActivityEnableContext",
+  "cuptiActivityEnableLatencyTimestamps",
+  "cuptiActivityEnableLaunchAttributes",
+  "cuptiActivityEnableRawTimestamps",
+  "cuptiActivityFlush",
+  "cuptiActivityFlushAll",
+  "cuptiActivityFlushPeriod",
+  "cuptiActivityGetAttribute",
+  "cuptiActivityGetNextRecord",
+  "cuptiActivityGetNumDroppedRecords",
+  "cuptiActivityPopExternalCorrelationId",
+  "cuptiActivityPushExternalCorrelationId",
+  "cuptiActivityRegisterCallbacks",
+  "cuptiActivityRegisterTimestampCallback",
+  "cuptiActivitySetAttribute",
+  "cuptiComputeCapabilitySupported",
+  "cuptiDeviceEnumEventDomains",
+  "cuptiDeviceEnumMetrics",
+  "cuptiDeviceGetAttribute",
+  "cuptiDeviceGetChipName",
+  "cuptiDeviceGetEventDomainAttribute",
+  "cuptiDeviceGetNumEventDomains",
+  "cuptiDeviceGetNumMetrics",
+  "cuptiDeviceSupported",
+  "cuptiDeviceVirtualizationMode",
+  "cuptiDisableKernelReplayMode",
+  "cuptiDisableLibcuda",
+  "cuptiDisableNonOverlappingMode",
+  "cuptiEnableAllDomains",
+  "cuptiEnableCallback",
+  "cuptiEnableDomain",
+  "cuptiEnableKernelReplayMode",
+  "cuptiEnableNonOverlappingMode",
+  "cuptiEnumEventDomains",
+  "cuptiEnumMetrics",
+  "cuptiEventDomainEnumEvents",
+  "cuptiEventDomainGetAttribute",
+  "cuptiEventDomainGetNumEvents",
+  "cuptiEventGetAttribute",
+  "cuptiEventGetIdFromName",
+  "cuptiEventGroupAddEvent",
+  "cuptiEventGroupCreate",
+  "cuptiEventGroupDestroy",
+  "cuptiEventGroupDisable",
+  "cuptiEventGroupEnable",
+  "cuptiEventGroupGetAttribute",
+  "cuptiEventGroupReadAllEvents",
+  "cuptiEventGroupReadEvent",
+  "cuptiEventGroupRemoveAllEvents",
+  "cuptiEventGroupRemoveEvent",
+  "cuptiEventGroupResetAllEvents",
+  "cuptiEventGroupSetAttribute",
+  "cuptiEventGroupSetDisable",
+  "cuptiEventGroupSetEnable",
+  "cuptiEventGroupSetsCreate",
+  "cuptiEventGroupSetsDestroy",
+  "cuptiFinalize",
+  "cuptiGetAutoBoostState",
+  "cuptiGetCallbackName",
+  "cuptiGetCallbackState",
+  "cuptiGetContextId",
+  "cuptiGetCubinCrc",
+  "cuptiGetDeviceId",
+  "cuptiGetErrorMessage",
+  "cuptiGetGlobalCallbackState",
+  "cuptiGetGraphId",
+  "cuptiGetGraphNodeId",
+  "cuptiGetLastError",
+  "cuptiGetNumContexts",
+  "cuptiGetNumEventDomains",
+  "cuptiGetNumMetrics",
+  "cuptiGetRecommendedBufferSize",
+  "cuptiGetResultString",
+  "cuptiGetSassToSourceCorrelation",
+  "cuptiGetStreamId",
+  "cuptiGetStreamIdEx",
+  "cuptiGetThreadIdType",
+  "cuptiGetTimestamp",
+  "cuptiGetVersion",
+  "cuptiKernelReplaySubscribeUpdate",
+  "cuptiMetricCreateEventGroupSets",
+  "cuptiMetricEnumEvents",
+  "cuptiMetricEnumProperties",
+  "cuptiMetricGetAttribute",
+  "cuptiMetricGetIdFromName",
+  "cuptiMetricGetNumEvents",
+  "cuptiMetricGetNumProperties",
+  "cuptiMetricGetRequiredEventGroupSets",
+  "cuptiMetricGetValue",
+  "cuptiMetricGetValue2",
+  "cuptiNvtxInitialize",
+  "cuptiNvtxInitialize2",
+  "cuptiOpenACCInitialize",
+  "cuptiOpenMpInitialize",
+  "cuptiOpenMpInitialize_v2",
+  "cuptiPCSamplingDisable",
+  "cuptiPCSamplingEnable",
+  "cuptiPCSamplingGetConfigurationAttribute",
+  "cuptiPCSamplingGetData",
+  "cuptiPCSamplingGetNumStallReasons",
+  "cuptiPCSamplingGetStallReasons",
+  "cuptiPCSamplingSetConfigurationAttribute",
+  "cuptiPCSamplingStart",
+  "cuptiPCSamplingStop",
+  "cuptiProfilerBeginPass",
+  "cuptiProfilerBeginSession",
+  "cuptiProfilerCounterDataImageCalculateScratchBufferSize",
+  "cuptiProfilerCounterDataImageCalculateSize",
+  "cuptiProfilerCounterDataImageInitialize",
+  "cuptiProfilerCounterDataImageInitializeScratchBuffer",
+  "cuptiProfilerDeInitialize",
+  "cuptiProfilerDeviceSupported",
+  "cuptiProfilerDisableProfiling",
+  "cuptiProfilerEnableProfiling",
+  "cuptiProfilerEndPass",
+  "cuptiProfilerEndSession",
+  "cuptiProfilerFlushCounterData",
+  "cuptiProfilerGetCounterAvailability",
+  "cuptiProfilerInitialize",
+  "cuptiProfilerPopRange",
+  "cuptiProfilerPushRange",
+  "cuptiProfilerSetConfig",
+  "cuptiProfilerUnsetConfig",
+  "cuptiRegisterComputeCrcCallback",
+  "cuptiSassMetricsDisable",
+  "cuptiSassMetricsEnable",
+  "cuptiSassMetricsFlushData",
+  "cuptiSassMetricsGetDataProperties",
+  "cuptiSassMetricsGetMetrics",
+  "cuptiSassMetricsGetNumOfMetrics",
+  "cuptiSassMetricsGetProperties",
+  "cuptiSassMetricsSetConfig",
+  "cuptiSassMetricsUnsetConfig",
+  "cuptiSetEventCollectionMode",
+  "cuptiSetThreadIdType",
+  "cuptiStateQuery",
+  "cuptiSubscribe",
+  "cuptiSupportedDomains",
+  "cuptiUnsubscribe",

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/cuda/cusolver.inc

@@ -0,0 +1,926 @@
+  "cublasCbatchAccGemm",
+  "cublasCbatchAccGemm_BufferSize",
+  "cublasCbatchGemm",
+  "cublasCbatchTrsm",
+  "cublasDbatchAccGemm",
+  "cublasDbatchAccGemm_BufferSize",
+  "cublasDbatchGemm",
+  "cublasDbatchTrsm",
+  "cublasSbatchAccGemm",
+  "cublasSbatchAccGemm_BufferSize",
+  "cublasSbatchGemm",
+  "cublasSbatchTrsm",
+  "cublasZbatchAccGemm",
+  "cublasZbatchAccGemm_BufferSize",
+  "cublasZbatchGemm",
+  "cublasZbatchTrsm",
+  "cusolverDnCCgels",
+  "cusolverDnCCgels_bufferSize",
+  "cusolverDnCCgesv",
+  "cusolverDnCCgesv_bufferSize",
+  "cusolverDnCEgels",
+  "cusolverDnCEgels_bufferSize",
+  "cusolverDnCEgesv",
+  "cusolverDnCEgesv_bufferSize",
+  "cusolverDnCKgels",
+  "cusolverDnCKgels_bufferSize",
+  "cusolverDnCKgesv",
+  "cusolverDnCKgesv_bufferSize",
+  "cusolverDnCYgels",
+  "cusolverDnCYgels_bufferSize",
+  "cusolverDnCYgesv",
+  "cusolverDnCYgesv_bufferSize",
+  "cusolverDnCaxpyHost",
+  "cusolverDnCeyeBatch",
+  "cusolverDnCgebrd",
+  "cusolverDnCgebrd_bufferSize",
+  "cusolverDnCgehd2",
+  "cusolverDnCgehd2_bufferSize",
+  "cusolverDnCgehrd",
+  "cusolverDnCgehrd_bufferSize",
+  "cusolverDnCgelqfHost",
+  "cusolverDnCgemmHost",
+  "cusolverDnCgeqlfHost",
+  "cusolverDnCgeqrf",
+  "cusolverDnCgeqrfHost",
+  "cusolverDnCgeqrf_ApI",
+  "cusolverDnCgeqrf_ApI_bufferSize",
+  "cusolverDnCgeqrf_bufferSize",
+  "cusolverDnCgercond",
+  "cusolverDnCgercond_bufferSize",
+  "cusolverDnCgesvd",
+  "cusolverDnCgesvd_bufferSize",
+  "cusolverDnCgesvdaStridedBatched",
+  "cusolverDnCgesvdaStridedBatched_bufferSize",
+  "cusolverDnCgesvdj",
+  "cusolverDnCgesvdjBatched",
+  "cusolverDnCgesvdjBatched_bufferSize",
+  "cusolverDnCgesvdj_bufferSize",
+  "cusolverDnCgetrf",
+  "cusolverDnCgetrf_bufferSize",
+  "cusolverDnCgetrs",
+  "cusolverDnCheevd",
+  "cusolverDnCheevd_bufferSize",
+  "cusolverDnCheevdx",
+  "cusolverDnCheevdx_bufferSize",
+  "cusolverDnCheevj",
+  "cusolverDnCheevjBatched",
+  "cusolverDnCheevjBatched_bufferSize",
+  "cusolverDnCheevj_bufferSize",
+  "cusolverDnChegst",
+  "cusolverDnChegst2",
+  "cusolverDnChegst2_bufferSize",
+  "cusolverDnChegst_bufferSize",
+  "cusolverDnChegvd",
+  "cusolverDnChegvd_bufferSize",
+  "cusolverDnChegvdx",
+  "cusolverDnChegvdx_bufferSize",
+  "cusolverDnChegvj",
+  "cusolverDnChegvj_bufferSize",
+  "cusolverDnChemv",
+  "cusolverDnChemv_bufferSize",
+  "cusolverDnChetrd",
+  "cusolverDnChetrd_bufferSize",
+  "cusolverDnClacpyHost",
+  "cusolverDnClahr2",
+  "cusolverDnClange",
+  "cusolverDnClangeHost",
+  "cusolverDnClange_bufferSize",
+  "cusolverDnClanhe",
+  "cusolverDnClanheHost",
+  "cusolverDnClanhe_bufferSize",
+  "cusolverDnClantrHost",
+  "cusolverDnClarfb",
+  "cusolverDnClarfgHost",
+  "cusolverDnClarft",
+  "cusolverDnClarft_bufferSize",
+  "cusolverDnClarnvHost",
+  "cusolverDnClascl",
+  "cusolverDnClasetHost",
+  "cusolverDnClaswp",
+  "cusolverDnClauum",
+  "cusolverDnClauumHost",
+  "cusolverDnClauum_bufferSize",
+  "cusolverDnCnrm2Host",
+  "cusolverDnCpolar",
+  "cusolverDnCpolar_bufferSize",
+  "cusolverDnCpotrf",
+  "cusolverDnCpotrfBatched",
+  "cusolverDnCpotrfHost",
+  "cusolverDnCpotrf_bufferSize",
+  "cusolverDnCpotri",
+  "cusolverDnCpotriHost",
+  "cusolverDnCpotri_bufferSize",
+  "cusolverDnCpotrs",
+  "cusolverDnCpotrsBatched",
+  "cusolverDnCpotrsHost",
+  "cusolverDnCreate",
+  "cusolverDnCreateGesvdjInfo",
+  "cusolverDnCreateParams",
+  "cusolverDnCreateSyevjInfo",
+  "cusolverDnCsscalHost",
+  "cusolverDnCsytrf",
+  "cusolverDnCsytrf_bufferSize",
+  "cusolverDnCsytri",
+  "cusolverDnCsytriHost",
+  "cusolverDnCsytri_bufferSize",
+  "cusolverDnCsytrsHost",
+  "cusolverDnCtrtriHost",
+  "cusolverDnCungbr",
+  "cusolverDnCungbrHost",
+  "cusolverDnCungbr_bufferSize",
+  "cusolverDnCunghrHost",
+  "cusolverDnCunglqHost",
+  "cusolverDnCungqr",
+  "cusolverDnCungqr_ApI",
+  "cusolverDnCungqr_ApI_bufferSize",
+  "cusolverDnCungqr_bufferSize",
+  "cusolverDnCungtr",
+  "cusolverDnCungtrHost",
+  "cusolverDnCungtr_bufferSize",
+  "cusolverDnCunmqr",
+  "cusolverDnCunmqrHost",
+  "cusolverDnCunmqr_bufferSize",
+  "cusolverDnCunmtr",
+  "cusolverDnCunmtrHost",
+  "cusolverDnCunmtr_bufferSize",
+  "cusolverDnDBgels",
+  "cusolverDnDBgels_bufferSize",
+  "cusolverDnDBgesv",
+  "cusolverDnDBgesv_bufferSize",
+  "cusolverDnDDgels",
+  "cusolverDnDDgels_bufferSize",
+  "cusolverDnDDgesv",
+  "cusolverDnDDgesv_bufferSize",
+  "cusolverDnDHgels",
+  "cusolverDnDHgels_bufferSize",
+  "cusolverDnDHgesv",
+  "cusolverDnDHgesv_bufferSize",
+  "cusolverDnDSgels",
+  "cusolverDnDSgels_bufferSize",
+  "cusolverDnDSgesv",
+  "cusolverDnDSgesv_bufferSize",
+  "cusolverDnDXgels",
+  "cusolverDnDXgels_bufferSize",
+  "cusolverDnDXgesv",
+  "cusolverDnDXgesv_bufferSize",
+  "cusolverDnDaxpyHost",
+  "cusolverDnDestroy",
+  "cusolverDnDestroyGesvdjInfo",
+  "cusolverDnDestroyParams",
+  "cusolverDnDestroySyevjInfo",
+  "cusolverDnDeyeBatch",
+  "cusolverDnDgebrd",
+  "cusolverDnDgebrd_bufferSize",
+  "cusolverDnDgehd2",
+  "cusolverDnDgehd2_bufferSize",
+  "cusolverDnDgehrd",
+  "cusolverDnDgehrd_bufferSize",
+  "cusolverDnDgelqfHost",
+  "cusolverDnDgemmHost",
+  "cusolverDnDgeqlfHost",
+  "cusolverDnDgeqrf",
+  "cusolverDnDgeqrfHost",
+  "cusolverDnDgeqrf_ApI",
+  "cusolverDnDgeqrf_ApI_bufferSize",
+  "cusolverDnDgeqrf_bufferSize",
+  "cusolverDnDgercond",
+  "cusolverDnDgercond_bufferSize",
+  "cusolverDnDgesvd",
+  "cusolverDnDgesvd_bufferSize",
+  "cusolverDnDgesvdaStridedBatched",
+  "cusolverDnDgesvdaStridedBatched_bufferSize",
+  "cusolverDnDgesvdj",
+  "cusolverDnDgesvdjBatched",
+  "cusolverDnDgesvdjBatched_bufferSize",
+  "cusolverDnDgesvdj_bufferSize",
+  "cusolverDnDgetrf",
+  "cusolverDnDgetrf_bufferSize",
+  "cusolverDnDgetrs",
+  "cusolverDnDlacpyHost",
+  "cusolverDnDlahr2",
+  "cusolverDnDlamchHost",
+  "cusolverDnDlange",
+  "cusolverDnDlangeHost",
+  "cusolverDnDlange_bufferSize",
+  "cusolverDnDlansy",
+  "cusolverDnDlansyHost",
+  "cusolverDnDlansy_bufferSize",
+  "cusolverDnDlantrHost",
+  "cusolverDnDlarfb",
+  "cusolverDnDlarfgHost",
+  "cusolverDnDlarft",
+  "cusolverDnDlarft_bufferSize",
+  "cusolverDnDlarnvHost",
+  "cusolverDnDlascl",
+  "cusolverDnDlasetHost",
+  "cusolverDnDlaswp",
+  "cusolverDnDlauum",
+  "cusolverDnDlauumHost",
+  "cusolverDnDlauum_bufferSize",
+  "cusolverDnDnrm2Host",
+  "cusolverDnDorgbr",
+  "cusolverDnDorgbrHost",
+  "cusolverDnDorgbr_bufferSize",
+  "cusolverDnDorghrHost",
+  "cusolverDnDorglqHost",
+  "cusolverDnDorgqr",
+  "cusolverDnDorgqr_ApI",
+  "cusolverDnDorgqr_ApI_bufferSize",
+  "cusolverDnDorgqr_bufferSize",
+  "cusolverDnDorgtr",
+  "cusolverDnDorgtrHost",
+  "cusolverDnDorgtr_bufferSize",
+  "cusolverDnDormqr",
+  "cusolverDnDormqrHost",
+  "cusolverDnDormqr_bufferSize",
+  "cusolverDnDormtr",
+  "cusolverDnDormtrHost",
+  "cusolverDnDormtr_bufferSize",
+  "cusolverDnDpolar",
+  "cusolverDnDpolar_bufferSize",
+  "cusolverDnDpotrf",
+  "cusolverDnDpotrfBatched",
+  "cusolverDnDpotrfHost",
+  "cusolverDnDpotrf_bufferSize",
+  "cusolverDnDpotri",
+  "cusolverDnDpotriHost",
+  "cusolverDnDpotri_bufferSize",
+  "cusolverDnDpotrs",
+  "cusolverDnDpotrsBatched",
+  "cusolverDnDpotrsHost",
+  "cusolverDnDscalHost",
+  "cusolverDnDsteqrHost",
+  "cusolverDnDsterfHost",
+  "cusolverDnDsyevd",
+  "cusolverDnDsyevd_bufferSize",
+  "cusolverDnDsyevdx",
+  "cusolverDnDsyevdx_bufferSize",
+  "cusolverDnDsyevj",
+  "cusolverDnDsyevjBatched",
+  "cusolverDnDsyevjBatched_bufferSize",
+  "cusolverDnDsyevj_bufferSize",
+  "cusolverDnDsygst",
+  "cusolverDnDsygst2",
+  "cusolverDnDsygst2_bufferSize",
+  "cusolverDnDsygst_bufferSize",
+  "cusolverDnDsygvd",
+  "cusolverDnDsygvd_bufferSize",
+  "cusolverDnDsygvdx",
+  "cusolverDnDsygvdx_bufferSize",
+  "cusolverDnDsygvj",
+  "cusolverDnDsygvj_bufferSize",
+  "cusolverDnDsymv",
+  "cusolverDnDsymv_bufferSize",
+  "cusolverDnDsytrd",
+  "cusolverDnDsytrd_bufferSize",
+  "cusolverDnDsytrf",
+  "cusolverDnDsytrf_bufferSize",
+  "cusolverDnDsytri",
+  "cusolverDnDsytriHost",
+  "cusolverDnDsytri_bufferSize",
+  "cusolverDnDsytrsHost",
+  "cusolverDnDtrtriHost",
+  "cusolverDnGeqrf",
+  "cusolverDnGeqrf_bufferSize",
+  "cusolverDnGesvd",
+  "cusolverDnGesvd_bufferSize",
+  "cusolverDnGetDeterministicMode",
+  "cusolverDnGetStream",
+  "cusolverDnGetrf",
+  "cusolverDnGetrf_bufferSize",
+  "cusolverDnGetrs",
+  "cusolverDnIRSInfosCreate",
+  "cusolverDnIRSInfosDestroy",
+  "cusolverDnIRSInfosGetMaxIters",
+  "cusolverDnIRSInfosGetNiters",
+  "cusolverDnIRSInfosGetOuterNiters",
+  "cusolverDnIRSInfosGetResidualHistory",
+  "cusolverDnIRSInfosRequestResidual",
+  "cusolverDnIRSParamsCreate",
+  "cusolverDnIRSParamsDestroy",
+  "cusolverDnIRSParamsDisableFallback",
+  "cusolverDnIRSParamsEnableFallback",
+  "cusolverDnIRSParamsGetMaxIters",
+  "cusolverDnIRSParamsSetMaxIters",
+  "cusolverDnIRSParamsSetMaxItersInner",
+  "cusolverDnIRSParamsSetRefinementSolver",
+  "cusolverDnIRSParamsSetSolverLowestPrecision",
+  "cusolverDnIRSParamsSetSolverMainPrecision",
+  "cusolverDnIRSParamsSetSolverPrecisions",
+  "cusolverDnIRSParamsSetTol",
+  "cusolverDnIRSParamsSetTolInner",
+  "cusolverDnIRSXgels",
+  "cusolverDnIRSXgels_bufferSize",
+  "cusolverDnIRSXgesv",
+  "cusolverDnIRSXgesv_bufferSize",
+  "cusolverDnPotrf",
+  "cusolverDnPotrf_bufferSize",
+  "cusolverDnPotrs",
+  "cusolverDnSBgels",
+  "cusolverDnSBgels_bufferSize",
+  "cusolverDnSBgesv",
+  "cusolverDnSBgesv_bufferSize",
+  "cusolverDnSHgels",
+  "cusolverDnSHgels_bufferSize",
+  "cusolverDnSHgesv",
+  "cusolverDnSHgesv_bufferSize",
+  "cusolverDnSSgels",
+  "cusolverDnSSgels_bufferSize",
+  "cusolverDnSSgesv",
+  "cusolverDnSSgesv_bufferSize",
+  "cusolverDnSXgels",
+  "cusolverDnSXgels_bufferSize",
+  "cusolverDnSXgesv",
+  "cusolverDnSXgesv_bufferSize",
+  "cusolverDnSaxpyHost",
+  "cusolverDnSetAdvOptions",
+  "cusolverDnSetDeterministicMode",
+  "cusolverDnSetStream",
+  "cusolverDnSeyeBatch",
+  "cusolverDnSgebrd",
+  "cusolverDnSgebrd_bufferSize",
+  "cusolverDnSgehd2",
+  "cusolverDnSgehd2_bufferSize",
+  "cusolverDnSgehrd",
+  "cusolverDnSgehrd_bufferSize",
+  "cusolverDnSgelqfHost",
+  "cusolverDnSgemmHost",
+  "cusolverDnSgeqlfHost",
+  "cusolverDnSgeqrf",
+  "cusolverDnSgeqrfHost",
+  "cusolverDnSgeqrf_ApI",
+  "cusolverDnSgeqrf_ApI_bufferSize",
+  "cusolverDnSgeqrf_bufferSize",
+  "cusolverDnSgercond",
+  "cusolverDnSgercond_bufferSize",
+  "cusolverDnSgesvd",
+  "cusolverDnSgesvd_bufferSize",
+  "cusolverDnSgesvdaStridedBatched",
+  "cusolverDnSgesvdaStridedBatched_bufferSize",
+  "cusolverDnSgesvdj",
+  "cusolverDnSgesvdjBatched",
+  "cusolverDnSgesvdjBatched_bufferSize",
+  "cusolverDnSgesvdj_bufferSize",
+  "cusolverDnSgetrf",
+  "cusolverDnSgetrf_bufferSize",
+  "cusolverDnSgetrs",
+  "cusolverDnSlacpyHost",
+  "cusolverDnSlahr2",
+  "cusolverDnSlamchHost",
+  "cusolverDnSlange",
+  "cusolverDnSlangeHost",
+  "cusolverDnSlange_bufferSize",
+  "cusolverDnSlansy",
+  "cusolverDnSlansyHost",
+  "cusolverDnSlansy_bufferSize",
+  "cusolverDnSlantrHost",
+  "cusolverDnSlarfb",
+  "cusolverDnSlarfgHost",
+  "cusolverDnSlarft",
+  "cusolverDnSlarft_bufferSize",
+  "cusolverDnSlarnvHost",
+  "cusolverDnSlascl",
+  "cusolverDnSlasetHost",
+  "cusolverDnSlaswp",
+  "cusolverDnSlauum",
+  "cusolverDnSlauumHost",
+  "cusolverDnSlauum_bufferSize",
+  "cusolverDnSnrm2Host",
+  "cusolverDnSorgbr",
+  "cusolverDnSorgbrHost",
+  "cusolverDnSorgbr_bufferSize",
+  "cusolverDnSorghrHost",
+  "cusolverDnSorglqHost",
+  "cusolverDnSorgqr",
+  "cusolverDnSorgqr_ApI",
+  "cusolverDnSorgqr_ApI_bufferSize",
+  "cusolverDnSorgqr_bufferSize",
+  "cusolverDnSorgtr",
+  "cusolverDnSorgtrHost",
+  "cusolverDnSorgtr_bufferSize",
+  "cusolverDnSormqr",
+  "cusolverDnSormqrHost",
+  "cusolverDnSormqr_bufferSize",
+  "cusolverDnSormtr",
+  "cusolverDnSormtrHost",
+  "cusolverDnSormtr_bufferSize",
+  "cusolverDnSpolar",
+  "cusolverDnSpolar_bufferSize",
+  "cusolverDnSpotrf",
+  "cusolverDnSpotrfBatched",
+  "cusolverDnSpotrfHost",
+  "cusolverDnSpotrf_bufferSize",
+  "cusolverDnSpotri",
+  "cusolverDnSpotriHost",
+  "cusolverDnSpotri_bufferSize",
+  "cusolverDnSpotrs",
+  "cusolverDnSpotrsBatched",
+  "cusolverDnSpotrsHost",
+  "cusolverDnSscalHost",
+  "cusolverDnSsteqrHost",
+  "cusolverDnSsterfHost",
+  "cusolverDnSsyevd",
+  "cusolverDnSsyevd_bufferSize",
+  "cusolverDnSsyevdx",
+  "cusolverDnSsyevdx_bufferSize",
+  "cusolverDnSsyevj",
+  "cusolverDnSsyevjBatched",
+  "cusolverDnSsyevjBatched_bufferSize",
+  "cusolverDnSsyevj_bufferSize",
+  "cusolverDnSsygst",
+  "cusolverDnSsygst2",
+  "cusolverDnSsygst2_bufferSize",
+  "cusolverDnSsygst_bufferSize",
+  "cusolverDnSsygvd",
+  "cusolverDnSsygvd_bufferSize",
+  "cusolverDnSsygvdx",
+  "cusolverDnSsygvdx_bufferSize",
+  "cusolverDnSsygvj",
+  "cusolverDnSsygvj_bufferSize",
+  "cusolverDnSsymv",
+  "cusolverDnSsymv_bufferSize",
+  "cusolverDnSsytrd",
+  "cusolverDnSsytrd_bufferSize",
+  "cusolverDnSsytrf",
+  "cusolverDnSsytrf_bufferSize",
+  "cusolverDnSsytri",
+  "cusolverDnSsytriHost",
+  "cusolverDnSsytri_bufferSize",
+  "cusolverDnSsytrsHost",
+  "cusolverDnStrtriHost",
+  "cusolverDnSyevd",
+  "cusolverDnSyevd_bufferSize",
+  "cusolverDnSyevdx",
+  "cusolverDnSyevdx_bufferSize",
+  "cusolverDnXfillRandNormalOnDevice",
+  "cusolverDnXfillRandNormalOnHost",
+  "cusolverDnXgeqrf",
+  "cusolverDnXgeqrf_bufferSize",
+  "cusolverDnXgesvd",
+  "cusolverDnXgesvd_bufferSize",
+  "cusolverDnXgesvdjGetResidual",
+  "cusolverDnXgesvdjGetSweeps",
+  "cusolverDnXgesvdjSetMaxSweeps",
+  "cusolverDnXgesvdjSetSortEig",
+  "cusolverDnXgesvdjSetTolerance",
+  "cusolverDnXgesvdp",
+  "cusolverDnXgesvdp_bufferSize",
+  "cusolverDnXgesvdr",
+  "cusolverDnXgesvdr_bufferSize",
+  "cusolverDnXgetrf",
+  "cusolverDnXgetrf_bufferSize",
+  "cusolverDnXgetrs",
+  "cusolverDnXpotrf",
+  "cusolverDnXpotrf_bufferSize",
+  "cusolverDnXpotrs",
+  "cusolverDnXsyevd",
+  "cusolverDnXsyevd_bufferSize",
+  "cusolverDnXsyevdx",
+  "cusolverDnXsyevdx_bufferSize",
+  "cusolverDnXsyevjGetResidual",
+  "cusolverDnXsyevjGetSweeps",
+  "cusolverDnXsyevjSetMaxSweeps",
+  "cusolverDnXsyevjSetSortEig",
+  "cusolverDnXsyevjSetTolerance",
+  "cusolverDnXsytrs",
+  "cusolverDnXsytrs_bufferSize",
+  "cusolverDnXtrtri",
+  "cusolverDnXtrtri_bufferSize",
+  "cusolverDnZCgels",
+  "cusolverDnZCgels_bufferSize",
+  "cusolverDnZCgesv",
+  "cusolverDnZCgesv_bufferSize",
+  "cusolverDnZEgels",
+  "cusolverDnZEgels_bufferSize",
+  "cusolverDnZEgesv",
+  "cusolverDnZEgesv_bufferSize",
+  "cusolverDnZKgels",
+  "cusolverDnZKgels_bufferSize",
+  "cusolverDnZKgesv",
+  "cusolverDnZKgesv_bufferSize",
+  "cusolverDnZYgels",
+  "cusolverDnZYgels_bufferSize",
+  "cusolverDnZYgesv",
+  "cusolverDnZYgesv_bufferSize",
+  "cusolverDnZZgels",
+  "cusolverDnZZgels_bufferSize",
+  "cusolverDnZZgesv",
+  "cusolverDnZZgesv_bufferSize",
+  "cusolverDnZaxpyHost",
+  "cusolverDnZdscalHost",
+  "cusolverDnZeyeBatch",
+  "cusolverDnZgebrd",
+  "cusolverDnZgebrd_bufferSize",
+  "cusolverDnZgehd2",
+  "cusolverDnZgehd2_bufferSize",
+  "cusolverDnZgehrd",
+  "cusolverDnZgehrd_bufferSize",
+  "cusolverDnZgelqfHost",
+  "cusolverDnZgemmHost",
+  "cusolverDnZgeqlfHost",
+  "cusolverDnZgeqrf",
+  "cusolverDnZgeqrfHost",
+  "cusolverDnZgeqrf_ApI",
+  "cusolverDnZgeqrf_ApI_bufferSize",
+  "cusolverDnZgeqrf_bufferSize",
+  "cusolverDnZgercond",
+  "cusolverDnZgercond_bufferSize",
+  "cusolverDnZgesvd",
+  "cusolverDnZgesvd_bufferSize",
+  "cusolverDnZgesvdaStridedBatched",
+  "cusolverDnZgesvdaStridedBatched_bufferSize",
+  "cusolverDnZgesvdj",
+  "cusolverDnZgesvdjBatched",
+  "cusolverDnZgesvdjBatched_bufferSize",
+  "cusolverDnZgesvdj_bufferSize",
+  "cusolverDnZgetrf",
+  "cusolverDnZgetrf_bufferSize",
+  "cusolverDnZgetrs",
+  "cusolverDnZheevd",
+  "cusolverDnZheevd_bufferSize",
+  "cusolverDnZheevdx",
+  "cusolverDnZheevdx_bufferSize",
+  "cusolverDnZheevj",
+  "cusolverDnZheevjBatched",
+  "cusolverDnZheevjBatched_bufferSize",
+  "cusolverDnZheevj_bufferSize",
+  "cusolverDnZhegst",
+  "cusolverDnZhegst2",
+  "cusolverDnZhegst2_bufferSize",
+  "cusolverDnZhegst_bufferSize",
+  "cusolverDnZhegvd",
+  "cusolverDnZhegvd_bufferSize",
+  "cusolverDnZhegvdx",
+  "cusolverDnZhegvdx_bufferSize",
+  "cusolverDnZhegvj",
+  "cusolverDnZhegvj_bufferSize",
+  "cusolverDnZhemv",
+  "cusolverDnZhemv_bufferSize",
+  "cusolverDnZhetrd",
+  "cusolverDnZhetrd_bufferSize",
+  "cusolverDnZlacpyHost",
+  "cusolverDnZlahr2",
+  "cusolverDnZlange",
+  "cusolverDnZlangeHost",
+  "cusolverDnZlange_bufferSize",
+  "cusolverDnZlanhe",
+  "cusolverDnZlanheHost",
+  "cusolverDnZlanhe_bufferSize",
+  "cusolverDnZlantrHost",
+  "cusolverDnZlarfb",
+  "cusolverDnZlarfgHost",
+  "cusolverDnZlarft",
+  "cusolverDnZlarft_bufferSize",
+  "cusolverDnZlarnvHost",
+  "cusolverDnZlascl",
+  "cusolverDnZlasetHost",
+  "cusolverDnZlaswp",
+  "cusolverDnZlauum",
+  "cusolverDnZlauumHost",
+  "cusolverDnZlauum_bufferSize",
+  "cusolverDnZnrm2Host",
+  "cusolverDnZpolar",
+  "cusolverDnZpolar_bufferSize",
+  "cusolverDnZpotrf",
+  "cusolverDnZpotrfBatched",
+  "cusolverDnZpotrfHost",
+  "cusolverDnZpotrf_bufferSize",
+  "cusolverDnZpotri",
+  "cusolverDnZpotriHost",
+  "cusolverDnZpotri_bufferSize",
+  "cusolverDnZpotrs",
+  "cusolverDnZpotrsBatched",
+  "cusolverDnZpotrsHost",
+  "cusolverDnZsytrf",
+  "cusolverDnZsytrf_bufferSize",
+  "cusolverDnZsytri",
+  "cusolverDnZsytriHost",
+  "cusolverDnZsytri_bufferSize",
+  "cusolverDnZsytrsHost",
+  "cusolverDnZtrtriHost",
+  "cusolverDnZungbr",
+  "cusolverDnZungbrHost",
+  "cusolverDnZungbr_bufferSize",
+  "cusolverDnZunghrHost",
+  "cusolverDnZunglqHost",
+  "cusolverDnZungqr",
+  "cusolverDnZungqr_ApI",
+  "cusolverDnZungqr_ApI_bufferSize",
+  "cusolverDnZungqr_bufferSize",
+  "cusolverDnZungtr",
+  "cusolverDnZungtrHost",
+  "cusolverDnZungtr_bufferSize",
+  "cusolverDnZunmqr",
+  "cusolverDnZunmqrHost",
+  "cusolverDnZunmqr_bufferSize",
+  "cusolverDnZunmtr",
+  "cusolverDnZunmtrHost",
+  "cusolverDnZunmtr_bufferSize",
+  "cusolverGetProperty",
+  "cusolverGetVersion",
+  "cusolverIidentityHost",
+  "cusolverRfAccessBundledFactorsDevice",
+  "cusolverRfAnalyze",
+  "cusolverRfBatchAnalyze",
+  "cusolverRfBatchRefactor",
+  "cusolverRfBatchResetValues",
+  "cusolverRfBatchSetupHost",
+  "cusolverRfBatchSolve",
+  "cusolverRfBatchZeroPivot",
+  "cusolverRfCreate",
+  "cusolverRfDestroy",
+  "cusolverRfExtractBundledFactorsHost",
+  "cusolverRfExtractSplitFactorsHost",
+  "cusolverRfGetAlgs",
+  "cusolverRfGetMatrixFormat",
+  "cusolverRfGetNumericBoostReport",
+  "cusolverRfGetNumericProperties",
+  "cusolverRfGetResetValuesFastMode",
+  "cusolverRfRefactor",
+  "cusolverRfResetValues",
+  "cusolverRfSetAlgs",
+  "cusolverRfSetMatrixFormat",
+  "cusolverRfSetNumericProperties",
+  "cusolverRfSetResetValuesFastMode",
+  "cusolverRfSetupDevice",
+  "cusolverRfSetupHost",
+  "cusolverRfSetupM",
+  "cusolverRfSolve",
+  "cusolverSpCcsrbtfHost",
+  "cusolverSpCcsrcholBufferInfo",
+  "cusolverSpCcsrcholBufferInfoHost",
+  "cusolverSpCcsrcholDiag",
+  "cusolverSpCcsrcholFactor",
+  "cusolverSpCcsrcholFactorHost",
+  "cusolverSpCcsrcholSolve",
+  "cusolverSpCcsrcholSolveHost",
+  "cusolverSpCcsrcholZeroPivot",
+  "cusolverSpCcsrcholZeroPivotHost",
+  "cusolverSpCcsreigsHost",
+  "cusolverSpCcsreigvsi",
+  "cusolverSpCcsreigvsiHost",
+  "cusolverSpCcsrlsqvqrHost",
+  "cusolverSpCcsrlsvchol",
+  "cusolverSpCcsrlsvcholHost",
+  "cusolverSpCcsrlsvluHost",
+  "cusolverSpCcsrlsvqr",
+  "cusolverSpCcsrlsvqrHost",
+  "cusolverSpCcsrluAnalysisHost",
+  "cusolverSpCcsrluBufferInfoHost",
+  "cusolverSpCcsrluExtractBTFHost",
+  "cusolverSpCcsrluExtractHost",
+  "cusolverSpCcsrluExtractMHost",
+  "cusolverSpCcsrluFactorHost",
+  "cusolverSpCcsrluSolveHost",
+  "cusolverSpCcsrluZeroPivotHost",
+  "cusolverSpCcsrlucondHost",
+  "cusolverSpCcsrqrBufferInfo",
+  "cusolverSpCcsrqrBufferInfoBatched",
+  "cusolverSpCcsrqrBufferInfoHost",
+  "cusolverSpCcsrqrFactor",
+  "cusolverSpCcsrqrFactorHost",
+  "cusolverSpCcsrqrSetup",
+  "cusolverSpCcsrqrSetupHost",
+  "cusolverSpCcsrqrSolve",
+  "cusolverSpCcsrqrSolveHost",
+  "cusolverSpCcsrqrZeroPivot",
+  "cusolverSpCcsrqrZeroPivotHost",
+  "cusolverSpCcsrqrrcond",
+  "cusolverSpCcsrqrsvBatched",
+  "cusolverSpCcsrsubm2denseHost",
+  "cusolverSpCcsrzfdHost",
+  "cusolverSpCreate",
+  "cusolverSpCreateCsrcholInfo",
+  "cusolverSpCreateCsrcholInfoHost",
+  "cusolverSpCreateCsrluInfoHost",
+  "cusolverSpCreateCsrqrInfo",
+  "cusolverSpCreateCsrqrInfoHost",
+  "cusolverSpCreateGluInfo",
+  "cusolverSpCreateSnluInfo",
+  "cusolverSpCsnluBuffersize",
+  "cusolverSpCsnluFactor",
+  "cusolverSpCsnluSolve",
+  "cusolverSpCsymgthr",
+  "cusolverSpCsymgthrHost",
+  "cusolverSpDcsrbtfHost",
+  "cusolverSpDcsrcholBufferInfo",
+  "cusolverSpDcsrcholBufferInfoHost",
+  "cusolverSpDcsrcholDiag",
+  "cusolverSpDcsrcholFactor",
+  "cusolverSpDcsrcholFactorHost",
+  "cusolverSpDcsrcholSolve",
+  "cusolverSpDcsrcholSolveHost",
+  "cusolverSpDcsrcholZeroPivot",
+  "cusolverSpDcsrcholZeroPivotHost",
+  "cusolverSpDcsreigsHost",
+  "cusolverSpDcsreigvsi",
+  "cusolverSpDcsreigvsiHost",
+  "cusolverSpDcsrlsqvqrHost",
+  "cusolverSpDcsrlsvchol",
+  "cusolverSpDcsrlsvcholHost",
+  "cusolverSpDcsrlsvluHost",
+  "cusolverSpDcsrlsvqr",
+  "cusolverSpDcsrlsvqrHost",
+  "cusolverSpDcsrluAnalysisHost",
+  "cusolverSpDcsrluBufferInfoHost",
+  "cusolverSpDcsrluExtractBTFHost",
+  "cusolverSpDcsrluExtractHost",
+  "cusolverSpDcsrluExtractMHost",
+  "cusolverSpDcsrluFactorHost",
+  "cusolverSpDcsrluSolveHost",
+  "cusolverSpDcsrluZeroPivotHost",
+  "cusolverSpDcsrlucondHost",
+  "cusolverSpDcsrqrBufferInfo",
+  "cusolverSpDcsrqrBufferInfoBatched",
+  "cusolverSpDcsrqrBufferInfoHost",
+  "cusolverSpDcsrqrFactor",
+  "cusolverSpDcsrqrFactorHost",
+  "cusolverSpDcsrqrSetup",
+  "cusolverSpDcsrqrSetupHost",
+  "cusolverSpDcsrqrSolve",
+  "cusolverSpDcsrqrSolveHost",
+  "cusolverSpDcsrqrZeroPivot",
+  "cusolverSpDcsrqrZeroPivotHost",
+  "cusolverSpDcsrqrrcond",
+  "cusolverSpDcsrqrsvBatched",
+  "cusolverSpDcsrsubm2denseHost",
+  "cusolverSpDcsrzfdHost",
+  "cusolverSpDestroy",
+  "cusolverSpDestroyCsrcholInfo",
+  "cusolverSpDestroyCsrcholInfoHost",
+  "cusolverSpDestroyCsrluInfoHost",
+  "cusolverSpDestroyCsrqrInfo",
+  "cusolverSpDestroyCsrqrInfoHost",
+  "cusolverSpDestroyGluInfo",
+  "cusolverSpDestroySnluInfo",
+  "cusolverSpDgluAnalysis",
+  "cusolverSpDgluBufferSize",
+  "cusolverSpDgluExtractMHost",
+  "cusolverSpDgluFactor",
+  "cusolverSpDgluNumericBoost",
+  "cusolverSpDgluReset",
+  "cusolverSpDgluSetup",
+  "cusolverSpDgluSetupByTile",
+  "cusolverSpDgluSolve",
+  "cusolverSpDnrminf",
+  "cusolverSpDsnluBuffersize",
+  "cusolverSpDsnluFactor",
+  "cusolverSpDsnluSolve",
+  "cusolverSpDsymgthr",
+  "cusolverSpDsymgthrHost",
+  "cusolverSpGetStream",
+  "cusolverSpLcsrqrBufferInfo",
+  "cusolverSpLcsrqrFactor",
+  "cusolverSpLcsrqrSetup",
+  "cusolverSpLcsrqrSolve",
+  "cusolverSpLcsrqrSolveRefine",
+  "cusolverSpLcsrqrZeroPivot",
+  "cusolverSpLcsrqrrcond",
+  "cusolverSpQcsrqrBufferInfo",
+  "cusolverSpQcsrqrFactor",
+  "cusolverSpQcsrqrSetup",
+  "cusolverSpQcsrqrSolve",
+  "cusolverSpQcsrqrSolveRefine",
+  "cusolverSpQcsrqrZeroPivot",
+  "cusolverSpQcsrqrrcond",
+  "cusolverSpScsrbtfHost",
+  "cusolverSpScsrcholBufferInfo",
+  "cusolverSpScsrcholBufferInfoHost",
+  "cusolverSpScsrcholDiag",
+  "cusolverSpScsrcholFactor",
+  "cusolverSpScsrcholFactorHost",
+  "cusolverSpScsrcholSolve",
+  "cusolverSpScsrcholSolveHost",
+  "cusolverSpScsrcholZeroPivot",
+  "cusolverSpScsrcholZeroPivotHost",
+  "cusolverSpScsreigsHost",
+  "cusolverSpScsreigvsi",
+  "cusolverSpScsreigvsiHost",
+  "cusolverSpScsrlsqvqrHost",
+  "cusolverSpScsrlsvchol",
+  "cusolverSpScsrlsvcholHost",
+  "cusolverSpScsrlsvluHost",
+  "cusolverSpScsrlsvqr",
+  "cusolverSpScsrlsvqrHost",
+  "cusolverSpScsrluAnalysisHost",
+  "cusolverSpScsrluBufferInfoHost",
+  "cusolverSpScsrluExtractBTFHost",
+  "cusolverSpScsrluExtractHost",
+  "cusolverSpScsrluExtractMHost",
+  "cusolverSpScsrluFactorHost",
+  "cusolverSpScsrluSolveHost",
+  "cusolverSpScsrluZeroPivotHost",
+  "cusolverSpScsrlucondHost",
+  "cusolverSpScsrqrBufferInfo",
+  "cusolverSpScsrqrBufferInfoBatched",
+  "cusolverSpScsrqrBufferInfoHost",
+  "cusolverSpScsrqrFactor",
+  "cusolverSpScsrqrFactorHost",
+  "cusolverSpScsrqrSetup",
+  "cusolverSpScsrqrSetupHost",
+  "cusolverSpScsrqrSolve",
+  "cusolverSpScsrqrSolveHost",
+  "cusolverSpScsrqrZeroPivot",
+  "cusolverSpScsrqrZeroPivotHost",
+  "cusolverSpScsrqrrcond",
+  "cusolverSpScsrqrsvBatched",
+  "cusolverSpScsrsubm2denseHost",
+  "cusolverSpScsrzfdHost",
+  "cusolverSpSetStream",
+  "cusolverSpSsnluBuffersize",
+  "cusolverSpSsnluFactor",
+  "cusolverSpSsnluSolve",
+  "cusolverSpSsymgthr",
+  "cusolverSpSsymgthrHost",
+  "cusolverSpXcsr2cscHost",
+  "cusolverSpXcsr2csc_bufferSizeHost",
+  "cusolverSpXcsrcholAnalysis",
+  "cusolverSpXcsrcholAnalysisHost",
+  "cusolverSpXcsrissymHost",
+  "cusolverSpXcsrluAnalysisHost",
+  "cusolverSpXcsrluConfigHost",
+  "cusolverSpXcsrluNnzHost",
+  "cusolverSpXcsrluNnzMHost",
+  "cusolverSpXcsrmetisndHost",
+  "cusolverSpXcsrnsepHost",
+  "cusolverSpXcsrpermHost",
+  "cusolverSpXcsrperm_bufferSizeHost",
+  "cusolverSpXcsrqrAnalysis",
+  "cusolverSpXcsrqrAnalysisBatched",
+  "cusolverSpXcsrqrAnalysisHost",
+  "cusolverSpXcsrqrConfigInfo",
+  "cusolverSpXcsrsubmHost",
+  "cusolverSpXcsrsubmNnzHost",
+  "cusolverSpXcsrsymamdHost",
+  "cusolverSpXcsrsymmdqHost",
+  "cusolverSpXcsrsympermHost",
+  "cusolverSpXcsrsymperm_bufferSizeHost",
+  "cusolverSpXcsrsymrcmHost",
+  "cusolverSpXgluZeroPivot",
+  "cusolverSpXsnluAnalysis",
+  "cusolverSpXsnluFlops",
+  "cusolverSpXsnluReport",
+  "cusolverSpXsnluResizeSupernodeBy",
+  "cusolverSpXsnluSetReorder",
+  "cusolverSpZcsrbtfHost",
+  "cusolverSpZcsrcholBufferInfo",
+  "cusolverSpZcsrcholBufferInfoHost",
+  "cusolverSpZcsrcholDiag",
+  "cusolverSpZcsrcholFactor",
+  "cusolverSpZcsrcholFactorHost",
+  "cusolverSpZcsrcholSolve",
+  "cusolverSpZcsrcholSolveHost",
+  "cusolverSpZcsrcholZeroPivot",
+  "cusolverSpZcsrcholZeroPivotHost",
+  "cusolverSpZcsreigsHost",
+  "cusolverSpZcsreigvsi",
+  "cusolverSpZcsreigvsiHost",
+  "cusolverSpZcsrlsqvqrHost",
+  "cusolverSpZcsrlsvchol",
+  "cusolverSpZcsrlsvcholHost",
+  "cusolverSpZcsrlsvluHost",
+  "cusolverSpZcsrlsvqr",
+  "cusolverSpZcsrlsvqrHost",
+  "cusolverSpZcsrluAnalysisHost",
+  "cusolverSpZcsrluBufferInfoHost",
+  "cusolverSpZcsrluExtractBTFHost",
+  "cusolverSpZcsrluExtractHost",
+  "cusolverSpZcsrluExtractMHost",
+  "cusolverSpZcsrluFactorHost",
+  "cusolverSpZcsrluSolveHost",
+  "cusolverSpZcsrluZeroPivotHost",
+  "cusolverSpZcsrlucondHost",
+  "cusolverSpZcsrqrBufferInfo",
+  "cusolverSpZcsrqrBufferInfoBatched",
+  "cusolverSpZcsrqrBufferInfoHost",
+  "cusolverSpZcsrqrFactor",
+  "cusolverSpZcsrqrFactorHost",
+  "cusolverSpZcsrqrSetup",
+  "cusolverSpZcsrqrSetupHost",
+  "cusolverSpZcsrqrSolve",
+  "cusolverSpZcsrqrSolveHost",
+  "cusolverSpZcsrqrZeroPivot",
+  "cusolverSpZcsrqrZeroPivotHost",
+  "cusolverSpZcsrqrrcond",
+  "cusolverSpZcsrqrsvBatched",
+  "cusolverSpZcsrsubm2denseHost",
+  "cusolverSpZcsrzfdHost",
+  "cusolverSpZsnluBuffersize",
+  "cusolverSpZsnluFactor",
+  "cusolverSpZsnluSolve",
+  "cusolverSpZsymgthr",
+  "cusolverSpZsymgthrHost",
+  "cusolverXcsrqr_dump",
+  "pegasusCcsr2dense",
+  "pegasusCcsrmvHost",
+  "pegasusDcsr2dense",
+  "pegasusDcsrmvHost",
+  "pegasusScsr2dense",
+  "pegasusScsrmvHost",
+  "pegasusXcoo2csr",
+  "pegasusXcooStableSortByRow",
+  "pegasusXcooStableSort_bufferSizeExt",
+  "pegasusXcsr2coo",
+  "pegasusZcsr2dense",
+  "pegasusZcsrmvHost",

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/cuda/cusparse.inc

@@ -0,0 +1,421 @@
+  "cusparseAxpby",
+  "cusparseBlockedEllGet",
+  "cusparseBsrSetStridedBatch",
+  "cusparseCbsr2csr",
+  "cusparseCbsric02",
+  "cusparseCbsric02_analysis",
+  "cusparseCbsric02_bufferSize",
+  "cusparseCbsrilu02",
+  "cusparseCbsrilu02_analysis",
+  "cusparseCbsrilu02_bufferSize",
+  "cusparseCbsrilu02_numericBoost",
+  "cusparseCbsrmm",
+  "cusparseCbsrmv",
+  "cusparseCbsrsm2_analysis",
+  "cusparseCbsrsm2_bufferSize",
+  "cusparseCbsrsm2_solve",
+  "cusparseCbsrsv2_analysis",
+  "cusparseCbsrsv2_bufferSize",
+  "cusparseCbsrsv2_solve",
+  "cusparseCbsrxmv",
+  "cusparseCcsr2bsr",
+  "cusparseCcsr2csr_compress",
+  "cusparseCcsr2csru",
+  "cusparseCcsr2gebsr",
+  "cusparseCcsr2gebsr_bufferSize",
+  "cusparseCcsrcolor",
+  "cusparseCcsrgeam2",
+  "cusparseCcsrgeam2_bufferSizeExt",
+  "cusparseCcsric02",
+  "cusparseCcsric02_analysis",
+  "cusparseCcsric02_bufferSize",
+  "cusparseCcsrilu02",
+  "cusparseCcsrilu02_analysis",
+  "cusparseCcsrilu02_bufferSize",
+  "cusparseCcsrilu02_numericBoost",
+  "cusparseCcsru2csr",
+  "cusparseCcsru2csr_bufferSizeExt",
+  "cusparseCgebsr2csr",
+  "cusparseCgebsr2gebsc",
+  "cusparseCgebsr2gebsc_bufferSize",
+  "cusparseCgebsr2gebsr",
+  "cusparseCgebsr2gebsr_bufferSize",
+  "cusparseCgemvi",
+  "cusparseCgemvi_bufferSize",
+  "cusparseCgpsvInterleavedBatch",
+  "cusparseCgpsvInterleavedBatch_bufferSizeExt",
+  "cusparseCgtsv2",
+  "cusparseCgtsv2StridedBatch",
+  "cusparseCgtsv2StridedBatch_bufferSizeExt",
+  "cusparseCgtsv2_bufferSizeExt",
+  "cusparseCgtsv2_nopivot",
+  "cusparseCgtsv2_nopivot_bufferSizeExt",
+  "cusparseCgtsvInterleavedBatch",
+  "cusparseCgtsvInterleavedBatch_bufferSizeExt",
+  "cusparseCnnz",
+  "cusparseCnnz_compress",
+  "cusparseConstBlockedEllGet",
+  "cusparseConstCooGet",
+  "cusparseConstCscGet",
+  "cusparseConstCsrGet",
+  "cusparseConstDnMatGet",
+  "cusparseConstDnMatGetValues",
+  "cusparseConstDnVecGet",
+  "cusparseConstDnVecGetValues",
+  "cusparseConstSpMatGetValues",
+  "cusparseConstSpVecGet",
+  "cusparseConstSpVecGetValues",
+  "cusparseCooGet",
+  "cusparseCooSetPointers",
+  "cusparseCooSetStridedBatch",
+  "cusparseCreate",
+  "cusparseCreateBlockedEll",
+  "cusparseCreateBsr",
+  "cusparseCreateBsric02Info",
+  "cusparseCreateBsrilu02Info",
+  "cusparseCreateBsrsm2Info",
+  "cusparseCreateBsrsv2Info",
+  "cusparseCreateColorInfo",
+  "cusparseCreateConstBlockedEll",
+  "cusparseCreateConstBsr",
+  "cusparseCreateConstCoo",
+  "cusparseCreateConstCsc",
+  "cusparseCreateConstCsr",
+  "cusparseCreateConstDnMat",
+  "cusparseCreateConstDnVec",
+  "cusparseCreateConstSlicedEll",
+  "cusparseCreateConstSpVec",
+  "cusparseCreateCoo",
+  "cusparseCreateCsc",
+  "cusparseCreateCsr",
+  "cusparseCreateCsric02Info",
+  "cusparseCreateCsrilu02Info",
+  "cusparseCreateCsru2csrInfo",
+  "cusparseCreateDnMat",
+  "cusparseCreateDnVec",
+  "cusparseCreateIdentityPermutation",
+  "cusparseCreateMatDescr",
+  "cusparseCreatePruneInfo",
+  "cusparseCreateSlicedEll",
+  "cusparseCreateSpVec",
+  "cusparseCscGet",
+  "cusparseCscSetPointers",
+  "cusparseCsr2cscEx2",
+  "cusparseCsr2cscEx2_bufferSize",
+  "cusparseCsrGet",
+  "cusparseCsrSetPointers",
+  "cusparseCsrSetStridedBatch",
+  "cusparseDbsr2csr",
+  "cusparseDbsric02",
+  "cusparseDbsric02_analysis",
+  "cusparseDbsric02_bufferSize",
+  "cusparseDbsrilu02",
+  "cusparseDbsrilu02_analysis",
+  "cusparseDbsrilu02_bufferSize",
+  "cusparseDbsrilu02_numericBoost",
+  "cusparseDbsrmm",
+  "cusparseDbsrmv",
+  "cusparseDbsrsm2_analysis",
+  "cusparseDbsrsm2_bufferSize",
+  "cusparseDbsrsm2_solve",
+  "cusparseDbsrsv2_analysis",
+  "cusparseDbsrsv2_bufferSize",
+  "cusparseDbsrsv2_solve",
+  "cusparseDbsrxmv",
+  "cusparseDcsr2bsr",
+  "cusparseDcsr2csr_compress",
+  "cusparseDcsr2csru",
+  "cusparseDcsr2gebsr",
+  "cusparseDcsr2gebsr_bufferSize",
+  "cusparseDcsrcolor",
+  "cusparseDcsrgeam2",
+  "cusparseDcsrgeam2_bufferSizeExt",
+  "cusparseDcsric02",
+  "cusparseDcsric02_analysis",
+  "cusparseDcsric02_bufferSize",
+  "cusparseDcsrilu02",
+  "cusparseDcsrilu02_analysis",
+  "cusparseDcsrilu02_bufferSize",
+  "cusparseDcsrilu02_numericBoost",
+  "cusparseDcsru2csr",
+  "cusparseDcsru2csr_bufferSizeExt",
+  "cusparseDenseToSparse_analysis",
+  "cusparseDenseToSparse_bufferSize",
+  "cusparseDenseToSparse_convert",
+  "cusparseDestroy",
+  "cusparseDestroyBsric02Info",
+  "cusparseDestroyBsrilu02Info",
+  "cusparseDestroyBsrsm2Info",
+  "cusparseDestroyBsrsv2Info",
+  "cusparseDestroyColorInfo",
+  "cusparseDestroyCsric02Info",
+  "cusparseDestroyCsrilu02Info",
+  "cusparseDestroyCsru2csrInfo",
+  "cusparseDestroyDnMat",
+  "cusparseDestroyDnVec",
+  "cusparseDestroyMatDescr",
+  "cusparseDestroyPruneInfo",
+  "cusparseDestroySpMat",
+  "cusparseDestroySpVec",
+  "cusparseDgebsr2csr",
+  "cusparseDgebsr2gebsc",
+  "cusparseDgebsr2gebsc_bufferSize",
+  "cusparseDgebsr2gebsr",
+  "cusparseDgebsr2gebsr_bufferSize",
+  "cusparseDgemvi",
+  "cusparseDgemvi_bufferSize",
+  "cusparseDgpsvInterleavedBatch",
+  "cusparseDgpsvInterleavedBatch_bufferSizeExt",
+  "cusparseDgtsv2",
+  "cusparseDgtsv2StridedBatch",
+  "cusparseDgtsv2StridedBatch_bufferSizeExt",
+  "cusparseDgtsv2_bufferSizeExt",
+  "cusparseDgtsv2_nopivot",
+  "cusparseDgtsv2_nopivot_bufferSizeExt",
+  "cusparseDgtsvInterleavedBatch",
+  "cusparseDgtsvInterleavedBatch_bufferSizeExt",
+  "cusparseDnMatGet",
+  "cusparseDnMatGetStridedBatch",
+  "cusparseDnMatGetValues",
+  "cusparseDnMatSetStridedBatch",
+  "cusparseDnMatSetValues",
+  "cusparseDnVecGet",
+  "cusparseDnVecGetValues",
+  "cusparseDnVecSetValues",
+  "cusparseDnnz",
+  "cusparseDnnz_compress",
+  "cusparseDpruneCsr2csr",
+  "cusparseDpruneCsr2csrByPercentage",
+  "cusparseDpruneCsr2csrByPercentage_bufferSizeExt",
+  "cusparseDpruneCsr2csrNnz",
+  "cusparseDpruneCsr2csrNnzByPercentage",
+  "cusparseDpruneCsr2csr_bufferSizeExt",
+  "cusparseDpruneDense2csr",
+  "cusparseDpruneDense2csrByPercentage",
+  "cusparseDpruneDense2csrByPercentage_bufferSizeExt",
+  "cusparseDpruneDense2csrNnz",
+  "cusparseDpruneDense2csrNnzByPercentage",
+  "cusparseDpruneDense2csr_bufferSizeExt",
+  "cusparseGather",
+  "cusparseGetErrorName",
+  "cusparseGetErrorString",
+  "cusparseGetMatDiagType",
+  "cusparseGetMatFillMode",
+  "cusparseGetMatIndexBase",
+  "cusparseGetMatType",
+  "cusparseGetPointerMode",
+  "cusparseGetProperty",
+  "cusparseGetStream",
+  "cusparseGetVersion",
+  "cusparseHpruneCsr2csr",
+  "cusparseHpruneCsr2csrByPercentage",
+  "cusparseHpruneCsr2csrByPercentage_bufferSizeExt",
+  "cusparseHpruneCsr2csrNnz",
+  "cusparseHpruneCsr2csrNnzByPercentage",
+  "cusparseHpruneCsr2csr_bufferSizeExt",
+  "cusparseHpruneDense2csr",
+  "cusparseHpruneDense2csrByPercentage",
+  "cusparseHpruneDense2csrByPercentage_bufferSizeExt",
+  "cusparseHpruneDense2csrNnz",
+  "cusparseHpruneDense2csrNnzByPercentage",
+  "cusparseHpruneDense2csr_bufferSizeExt",
+  "cusparseLoggerForceDisable",
+  "cusparseLoggerOpenFile",
+  "cusparseLoggerSetCallback",
+  "cusparseLoggerSetFile",
+  "cusparseLoggerSetLevel",
+  "cusparseLoggerSetMask",
+  "cusparseRot",
+  "cusparseSDDMM",
+  "cusparseSDDMM_bufferSize",
+  "cusparseSDDMM_preprocess",
+  "cusparseSbsr2csr",
+  "cusparseSbsric02",
+  "cusparseSbsric02_analysis",
+  "cusparseSbsric02_bufferSize",
+  "cusparseSbsrilu02",
+  "cusparseSbsrilu02_analysis",
+  "cusparseSbsrilu02_bufferSize",
+  "cusparseSbsrilu02_numericBoost",
+  "cusparseSbsrmm",
+  "cusparseSbsrmv",
+  "cusparseSbsrsm2_analysis",
+  "cusparseSbsrsm2_bufferSize",
+  "cusparseSbsrsm2_solve",
+  "cusparseSbsrsv2_analysis",
+  "cusparseSbsrsv2_bufferSize",
+  "cusparseSbsrsv2_solve",
+  "cusparseSbsrxmv",
+  "cusparseScatter",
+  "cusparseScsr2bsr",
+  "cusparseScsr2csr_compress",
+  "cusparseScsr2csru",
+  "cusparseScsr2gebsr",
+  "cusparseScsr2gebsr_bufferSize",
+  "cusparseScsrcolor",
+  "cusparseScsrgeam2",
+  "cusparseScsrgeam2_bufferSizeExt",
+  "cusparseScsric02",
+  "cusparseScsric02_analysis",
+  "cusparseScsric02_bufferSize",
+  "cusparseScsrilu02",
+  "cusparseScsrilu02_analysis",
+  "cusparseScsrilu02_bufferSize",
+  "cusparseScsrilu02_numericBoost",
+  "cusparseScsru2csr",
+  "cusparseScsru2csr_bufferSizeExt",
+  "cusparseSetMatDiagType",
+  "cusparseSetMatFillMode",
+  "cusparseSetMatIndexBase",
+  "cusparseSetMatType",
+  "cusparseSetPointerMode",
+  "cusparseSetStream",
+  "cusparseSgebsr2csr",
+  "cusparseSgebsr2gebsc",
+  "cusparseSgebsr2gebsc_bufferSize",
+  "cusparseSgebsr2gebsr",
+  "cusparseSgebsr2gebsr_bufferSize",
+  "cusparseSgemvi",
+  "cusparseSgemvi_bufferSize",
+  "cusparseSgpsvInterleavedBatch",
+  "cusparseSgpsvInterleavedBatch_bufferSizeExt",
+  "cusparseSgtsv2",
+  "cusparseSgtsv2StridedBatch",
+  "cusparseSgtsv2StridedBatch_bufferSizeExt",
+  "cusparseSgtsv2_bufferSizeExt",
+  "cusparseSgtsv2_nopivot",
+  "cusparseSgtsv2_nopivot_bufferSizeExt",
+  "cusparseSgtsvInterleavedBatch",
+  "cusparseSgtsvInterleavedBatch_bufferSizeExt",
+  "cusparseSnnz",
+  "cusparseSnnz_compress",
+  "cusparseSpGEMM_compute",
+  "cusparseSpGEMM_copy",
+  "cusparseSpGEMM_createDescr",
+  "cusparseSpGEMM_destroyDescr",
+  "cusparseSpGEMM_estimateMemory",
+  "cusparseSpGEMM_getNumProducts",
+  "cusparseSpGEMM_workEstimation",
+  "cusparseSpGEMMreuse_compute",
+  "cusparseSpGEMMreuse_copy",
+  "cusparseSpGEMMreuse_nnz",
+  "cusparseSpGEMMreuse_workEstimation",
+  "cusparseSpMM",
+  "cusparseSpMMOp",
+  "cusparseSpMMOp_createPlan",
+  "cusparseSpMMOp_destroyPlan",
+  "cusparseSpMM_bufferSize",
+  "cusparseSpMM_preprocess",
+  "cusparseSpMV",
+  "cusparseSpMV_bufferSize",
+  "cusparseSpMatGetAttribute",
+  "cusparseSpMatGetFormat",
+  "cusparseSpMatGetIndexBase",
+  "cusparseSpMatGetSize",
+  "cusparseSpMatGetStridedBatch",
+  "cusparseSpMatGetValues",
+  "cusparseSpMatSetAttribute",
+  "cusparseSpMatSetValues",
+  "cusparseSpSM_analysis",
+  "cusparseSpSM_bufferSize",
+  "cusparseSpSM_createDescr",
+  "cusparseSpSM_destroyDescr",
+  "cusparseSpSM_solve",
+  "cusparseSpSV_analysis",
+  "cusparseSpSV_bufferSize",
+  "cusparseSpSV_createDescr",
+  "cusparseSpSV_destroyDescr",
+  "cusparseSpSV_solve",
+  "cusparseSpSV_updateMatrix",
+  "cusparseSpVV",
+  "cusparseSpVV_bufferSize",
+  "cusparseSpVecGet",
+  "cusparseSpVecGetIndexBase",
+  "cusparseSpVecGetValues",
+  "cusparseSpVecSetValues",
+  "cusparseSparseToDense",
+  "cusparseSparseToDense_bufferSize",
+  "cusparseSpruneCsr2csr",
+  "cusparseSpruneCsr2csrByPercentage",
+  "cusparseSpruneCsr2csrByPercentage_bufferSizeExt",
+  "cusparseSpruneCsr2csrNnz",
+  "cusparseSpruneCsr2csrNnzByPercentage",
+  "cusparseSpruneCsr2csr_bufferSizeExt",
+  "cusparseSpruneDense2csr",
+  "cusparseSpruneDense2csrByPercentage",
+  "cusparseSpruneDense2csrByPercentage_bufferSizeExt",
+  "cusparseSpruneDense2csrNnz",
+  "cusparseSpruneDense2csrNnzByPercentage",
+  "cusparseSpruneDense2csr_bufferSizeExt",
+  "cusparseXbsric02_zeroPivot",
+  "cusparseXbsrilu02_zeroPivot",
+  "cusparseXbsrsm2_zeroPivot",
+  "cusparseXbsrsv2_zeroPivot",
+  "cusparseXcoo2csr",
+  "cusparseXcoosortByColumn",
+  "cusparseXcoosortByRow",
+  "cusparseXcoosort_bufferSizeExt",
+  "cusparseXcscsort",
+  "cusparseXcscsort_bufferSizeExt",
+  "cusparseXcsr2bsrNnz",
+  "cusparseXcsr2coo",
+  "cusparseXcsr2gebsrNnz",
+  "cusparseXcsrgeam2Nnz",
+  "cusparseXcsric02_zeroPivot",
+  "cusparseXcsrilu02_zeroPivot",
+  "cusparseXcsrsort",
+  "cusparseXcsrsort_bufferSizeExt",
+  "cusparseXgebsr2gebsrNnz",
+  "cusparseZbsr2csr",
+  "cusparseZbsric02",
+  "cusparseZbsric02_analysis",
+  "cusparseZbsric02_bufferSize",
+  "cusparseZbsrilu02",
+  "cusparseZbsrilu02_analysis",
+  "cusparseZbsrilu02_bufferSize",
+  "cusparseZbsrilu02_numericBoost",
+  "cusparseZbsrmm",
+  "cusparseZbsrmv",
+  "cusparseZbsrsm2_analysis",
+  "cusparseZbsrsm2_bufferSize",
+  "cusparseZbsrsm2_solve",
+  "cusparseZbsrsv2_analysis",
+  "cusparseZbsrsv2_bufferSize",
+  "cusparseZbsrsv2_solve",
+  "cusparseZbsrxmv",
+  "cusparseZcsr2bsr",
+  "cusparseZcsr2csr_compress",
+  "cusparseZcsr2csru",
+  "cusparseZcsr2gebsr",
+  "cusparseZcsr2gebsr_bufferSize",
+  "cusparseZcsrcolor",
+  "cusparseZcsrgeam2",
+  "cusparseZcsrgeam2_bufferSizeExt",
+  "cusparseZcsric02",
+  "cusparseZcsric02_analysis",
+  "cusparseZcsric02_bufferSize",
+  "cusparseZcsrilu02",
+  "cusparseZcsrilu02_analysis",
+  "cusparseZcsrilu02_bufferSize",
+  "cusparseZcsrilu02_numericBoost",
+  "cusparseZcsru2csr",
+  "cusparseZcsru2csr_bufferSizeExt",
+  "cusparseZgebsr2csr",
+  "cusparseZgebsr2gebsc",
+  "cusparseZgebsr2gebsc_bufferSize",
+  "cusparseZgebsr2gebsr",
+  "cusparseZgebsr2gebsr_bufferSize",
+  "cusparseZgemvi",
+  "cusparseZgemvi_bufferSize",
+  "cusparseZgpsvInterleavedBatch",
+  "cusparseZgpsvInterleavedBatch_bufferSizeExt",
+  "cusparseZgtsv2",
+  "cusparseZgtsv2StridedBatch",
+  "cusparseZgtsv2StridedBatch_bufferSizeExt",
+  "cusparseZgtsv2_bufferSizeExt",
+  "cusparseZgtsv2_nopivot",
+  "cusparseZgtsv2_nopivot_bufferSizeExt",
+  "cusparseZgtsvInterleavedBatch",
+  "cusparseZgtsvInterleavedBatch_bufferSizeExt",
+  "cusparseZnnz",
+  "cusparseZnnz_compress",

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/core/bitmap.h

@@ -0,0 +1,107 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_CORE_BITMAP_H_
+#define TENSORFLOW_TSL_LIB_CORE_BITMAP_H_
+
+#include <string>
+
+#include "tsl/platform/logging.h"
+
+namespace tsl {
+namespace core {
+
+class Bitmap {
+ public:
+  // Create a bitmap that holds 0 bits.
+  Bitmap();
+
+  // Create a bitmap that holds n bits, all initially zero.
+  explicit Bitmap(size_t n);
+
+  ~Bitmap();
+
+  Bitmap(const Bitmap&) = delete;
+  Bitmap& operator=(const Bitmap&) = delete;
+
+  // Return the number of bits that the bitmap can hold.
+  size_t bits() const;
+
+  // Replace contents of *this with a bitmap of n bits, all set to zero.
+  void Reset(size_t n);
+
+  // Return the contents of the ith bit.
+  // REQUIRES: i < bits()
+  bool get(size_t i) const;
+
+  // Set the contents of the ith bit to true.
+  // REQUIRES: i < bits()
+  void set(size_t i);
+
+  // Set the contents of the ith bit to false.
+  // REQUIRES: i < bits()
+  void clear(size_t i);
+
+  // Return the smallest i such that i >= start and !get(i).
+  // Returns bits() if no such i exists.
+  size_t FirstUnset(size_t start) const;
+
+  // Returns the bitmap as an ascii string of '0' and '1' characters, bits()
+  // characters in length.
+  std::string ToString() const;
+
+ private:
+  typedef uint32_t Word;
+  static constexpr size_t kBits = 32;
+
+  // Return the number of words needed to store n bits.
+  static size_t NumWords(size_t n) { return (n + kBits - 1) / kBits; }
+
+  // Return the mask to use for the ith bit in a word.
+  static Word Mask(size_t i) { return 1ull << i; }
+
+  size_t nbits_;  // Length of bitmap in bits.
+  Word* word_;
+};
+
+// Implementation details follow.  Clients should ignore.
+
+inline Bitmap::Bitmap() : nbits_(0), word_(nullptr) {}
+
+inline Bitmap::Bitmap(size_t n) : Bitmap() { Reset(n); }
+
+inline Bitmap::~Bitmap() { delete[] word_; }
+
+inline size_t Bitmap::bits() const { return nbits_; }
+
+inline bool Bitmap::get(size_t i) const {
+  DCHECK_LT(i, nbits_);
+  return word_[i / kBits] & Mask(i % kBits);
+}
+
+inline void Bitmap::set(size_t i) {
+  DCHECK_LT(i, nbits_);
+  word_[i / kBits] |= Mask(i % kBits);
+}
+
+inline void Bitmap::clear(size_t i) {
+  DCHECK_LT(i, nbits_);
+  word_[i / kBits] &= ~Mask(i % kBits);
+}
+
+}  // namespace core
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_CORE_BITMAP_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/core/bits.h

@@ -0,0 +1,120 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_CORE_BITS_H_
+#define TENSORFLOW_TSL_LIB_CORE_BITS_H_
+
+#include <cstdint>
+
+#include "absl/numeric/bits.h"
+#include "tsl/platform/logging.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+
+// Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+int Log2Floor(uint32 n);
+int Log2Floor64(uint64 n);
+
+// Return ceiling(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+int Log2Ceiling(uint32 n);
+int Log2Ceiling64(uint64 n);
+
+// ------------------------------------------------------------------------
+// Implementation details follow
+// ------------------------------------------------------------------------
+
+#if defined(__GNUC__)
+
+// Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+inline int Log2Floor(uint32 n) { return n == 0 ? -1 : 31 ^ __builtin_clz(n); }
+
+// Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+inline int Log2Floor64(uint64 n) {
+  return n == 0 ? -1 : 63 ^ __builtin_clzll(n);
+}
+
+#else
+
+// Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+inline int Log2Floor(uint32 n) {
+  if (n == 0) return -1;
+  int log = 0;
+  uint32 value = n;
+  for (int i = 4; i >= 0; --i) {
+    int shift = (1 << i);
+    uint32 x = value >> shift;
+    if (x != 0) {
+      value = x;
+      log += shift;
+    }
+  }
+  assert(value == 1);
+  return log;
+}
+
+// Return floor(log2(n)) for positive integer n.  Returns -1 iff n == 0.
+// Log2Floor64() is defined in terms of Log2Floor32()
+inline int Log2Floor64(uint64 n) {
+  const uint32 topbits = static_cast<uint32>(n >> 32);
+  if (topbits == 0) {
+    // Top bits are zero, so scan in bottom bits
+    return Log2Floor(static_cast<uint32>(n));
+  } else {
+    return 32 + Log2Floor(topbits);
+  }
+}
+
+#endif
+
+inline int Log2Ceiling(uint32 n) {
+  int floor = Log2Floor(n);
+  if (n == (n & ~(n - 1)))  // zero or a power of two
+    return floor;
+  else
+    return floor + 1;
+}
+
+inline int Log2Ceiling64(uint64 n) {
+  int floor = Log2Floor64(n);
+  if (n == (n & ~(n - 1)))  // zero or a power of two
+    return floor;
+  else
+    return floor + 1;
+}
+
+inline uint32 NextPowerOfTwo(uint32 value) {
+  int exponent = Log2Ceiling(value);
+  DCHECK_LT(exponent, std::numeric_limits<uint32>::digits);
+  return 1 << exponent;
+}
+
+inline uint64 NextPowerOfTwo64(uint64 value) {
+  int exponent = Log2Ceiling(value);
+  DCHECK_LT(exponent, std::numeric_limits<uint64>::digits);
+  return 1LL << exponent;
+}
+
+inline int64_t NextPowerOfTwoS64(int64_t value) {
+  constexpr int64_t kMaxRepresentablePowerOfTwo =
+      static_cast<int64_t>(uint64_t{1} << 62);
+  DCHECK_GE(value, 0);
+  DCHECK_LE(value, kMaxRepresentablePowerOfTwo);
+  return static_cast<int64_t>(absl::bit_ceil(static_cast<uint64_t>(value)));
+}
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_CORE_BITS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/core/status_test_util.h

@@ -0,0 +1,33 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_CORE_STATUS_TEST_UTIL_H_
+#define TENSORFLOW_TSL_LIB_CORE_STATUS_TEST_UTIL_H_
+
+#include "tsl/platform/status.h"
+#include "tsl/platform/test.h"
+
+// Macros for testing the results of functions that return tensorflow::Status.
+#define TF_EXPECT_OK(statement) EXPECT_EQ(::tsl::OkStatus(), (statement))
+#define TF_ASSERT_OK(statement) ASSERT_EQ(::tsl::OkStatus(), (statement))
+
+// There are no EXPECT_NOT_OK/ASSERT_NOT_OK macros since they would not
+// provide much value (when they fail, they would just print the OK status
+// which conveys no more information than EXPECT_FALSE(status.ok());
+// If you want to check for particular errors, a better alternative is with
+// status matchers:
+// EXPECT_THAT(s, tensorflow::testing::StatusIs(status.code(), "message"));
+
+#endif  // TENSORFLOW_TSL_LIB_CORE_STATUS_TEST_UTIL_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/flatmap.h

@@ -0,0 +1,396 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_FLATMAP_H_
+#define TENSORFLOW_TSL_LIB_GTL_FLATMAP_H_
+
+#include <stddef.h>
+
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
+#include "tsl/lib/gtl/flatrep.h"
+#include "tsl/platform/hash.h"
+#include "tsl/platform/logging.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace gtl {
+
+// FlatMap<K,V,...> provides a map from K to V.
+//
+// The map is implemented using an open-addressed hash table.  A
+// single array holds entire map contents and collisions are resolved
+// by probing at a sequence of locations in the array.
+template <typename Key, typename Val, class Hash = hash<Key>,
+          class Eq = std::equal_to<Key>>
+class FlatMap {
+ private:
+  // Forward declare some internal types needed in public section.
+  struct Bucket;
+
+  // We cannot use std::pair<> since internal representation stores
+  // keys and values in separate arrays, so we make a custom struct
+  // that holds references to the internal key, value elements.
+  //
+  // We define the struct as private ValueType, and typedef it as public
+  // value_type, to work around a gcc bug when compiling the iterators.
+  struct ValueType {
+    typedef Key first_type;
+    typedef Val second_type;
+
+    const Key& first;
+    Val& second;
+    ValueType(const Key& k, Val& v) : first(k), second(v) {}
+  };
+
+ public:
+  typedef Key key_type;
+  typedef Val mapped_type;
+  typedef Hash hasher;
+  typedef Eq key_equal;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef ValueType value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+  FlatMap() : FlatMap(1) {}
+
+  explicit FlatMap(size_t N, const Hash& hf = Hash(), const Eq& eq = Eq())
+      : rep_(N, hf, eq) {}
+
+  FlatMap(const FlatMap& src) : rep_(src.rep_) {}
+
+  // Move constructor leaves src in a valid but unspecified state (same as
+  // std::unordered_map).
+  FlatMap(FlatMap&& src) : rep_(std::move(src.rep_)) {}
+
+  template <typename InputIter>
+  FlatMap(InputIter first, InputIter last, size_t N = 1,
+          const Hash& hf = Hash(), const Eq& eq = Eq())
+      : FlatMap(N, hf, eq) {
+    insert(first, last);
+  }
+
+  FlatMap(std::initializer_list<std::pair<const Key, Val>> init, size_t N = 1,
+          const Hash& hf = Hash(), const Eq& eq = Eq())
+      : FlatMap(init.begin(), init.end(), N, hf, eq) {}
+
+  FlatMap& operator=(const FlatMap& src) {
+    rep_.CopyFrom(src.rep_);
+    return *this;
+  }
+
+  // Move-assignment operator leaves src in a valid but unspecified state (same
+  // as std::unordered_map).
+  FlatMap& operator=(FlatMap&& src) {
+    rep_.MoveFrom(std::move(src.rep_));
+    return *this;
+  }
+
+  ~FlatMap() {}
+
+  void swap(FlatMap& x) { rep_.swap(x.rep_); }
+  void clear_no_resize() { rep_.clear_no_resize(); }
+  void clear() { rep_.clear(); }
+  void reserve(size_t N) { rep_.Resize(std::max(N, size())); }
+  void rehash(size_t N) { rep_.Resize(std::max(N, size())); }
+  void resize(size_t N) { rep_.Resize(std::max(N, size())); }
+  size_t size() const { return rep_.size(); }
+  bool empty() const { return size() == 0; }
+  size_t bucket_count() const { return rep_.bucket_count(); }
+  hasher hash_function() const { return rep_.hash_function(); }
+  key_equal key_eq() const { return rep_.key_eq(); }
+
+  class iterator {
+   public:
+    typedef typename FlatMap::difference_type difference_type;
+    typedef typename FlatMap::value_type value_type;
+    typedef typename FlatMap::pointer pointer;
+    typedef typename FlatMap::reference reference;
+    typedef ::std::forward_iterator_tag iterator_category;
+
+    iterator() : b_(nullptr), end_(nullptr), i_(0) {}
+
+    // Make iterator pointing at first element at or after b.
+    iterator(Bucket* b, Bucket* end) : b_(b), end_(end), i_(0) { SkipUnused(); }
+
+    // Make iterator pointing exactly at ith element in b, which must exist.
+    iterator(Bucket* b, Bucket* end, uint32 i) : b_(b), end_(end), i_(i) {
+      FillValue();
+    }
+
+    reference operator*() { return *val(); }
+    pointer operator->() { return val(); }
+    bool operator==(const iterator& x) const {
+      return b_ == x.b_ && i_ == x.i_;
+    }
+    bool operator!=(const iterator& x) const { return !(*this == x); }
+    iterator& operator++() {
+      DCHECK(b_ != end_);
+      i_++;
+      SkipUnused();
+      return *this;
+    }
+    iterator operator++(int /*indicates postfix*/) {
+      iterator tmp(*this);
+      ++*this;
+      return tmp;
+    }
+
+   private:
+    friend class FlatMap;
+    Bucket* b_;
+    Bucket* end_;
+    char space_ alignas(value_type)[sizeof(value_type)];
+    uint32 i_;
+
+    pointer val() { return reinterpret_cast<pointer>(space_); }
+    void FillValue() { new (space_) value_type(b_->key(i_), b_->val(i_)); }
+    void SkipUnused() {
+      while (b_ < end_) {
+        if (i_ >= Rep::kWidth) {
+          i_ = 0;
+          b_++;
+        } else if (b_->marker[i_] < 2) {
+          i_++;
+        } else {
+          FillValue();
+          break;
+        }
+      }
+    }
+  };
+
+  class const_iterator {
+   private:
+    mutable iterator rep_;  // Share state and logic with non-const iterator.
+
+   public:
+    typedef typename FlatMap::difference_type difference_type;
+    typedef typename FlatMap::value_type value_type;
+    typedef typename FlatMap::const_pointer pointer;
+    typedef typename FlatMap::const_reference reference;
+    typedef ::std::forward_iterator_tag iterator_category;
+
+    const_iterator() : rep_() {}
+    const_iterator(Bucket* start, Bucket* end) : rep_(start, end) {}
+    const_iterator(Bucket* b, Bucket* end, uint32 i) : rep_(b, end, i) {}
+
+    reference operator*() const { return *rep_.val(); }
+    pointer operator->() const { return rep_.val(); }
+    bool operator==(const const_iterator& x) const { return rep_ == x.rep_; }
+    bool operator!=(const const_iterator& x) const { return rep_ != x.rep_; }
+    const_iterator& operator++() {
+      ++rep_;
+      return *this;
+    }
+    const_iterator operator++(int /*indicates postfix*/) {
+      const_iterator tmp(*this);
+      ++*this;
+      return tmp;
+    }
+  };
+
+  iterator begin() { return iterator(rep_.start(), rep_.limit()); }
+  iterator end() { return iterator(rep_.limit(), rep_.limit()); }
+  const_iterator begin() const {
+    return const_iterator(rep_.start(), rep_.limit());
+  }
+  const_iterator end() const {
+    return const_iterator(rep_.limit(), rep_.limit());
+  }
+
+  size_t count(const Key& k) const { return rep_.Find(k).found ? 1 : 0; }
+  iterator find(const Key& k) {
+    auto r = rep_.Find(k);
+    return r.found ? iterator(r.b, rep_.limit(), r.index) : end();
+  }
+  const_iterator find(const Key& k) const {
+    auto r = rep_.Find(k);
+    return r.found ? const_iterator(r.b, rep_.limit(), r.index) : end();
+  }
+
+  Val& at(const Key& k) {
+    auto r = rep_.Find(k);
+    DCHECK(r.found);
+    return r.b->val(r.index);
+  }
+  const Val& at(const Key& k) const {
+    auto r = rep_.Find(k);
+    DCHECK(r.found);
+    return r.b->val(r.index);
+  }
+
+  template <typename P>
+  std::pair<iterator, bool> insert(const P& p) {
+    return Insert(p.first, p.second);
+  }
+  std::pair<iterator, bool> insert(const std::pair<const Key, Val>& p) {
+    return Insert(p.first, p.second);
+  }
+  template <typename InputIter>
+  void insert(InputIter first, InputIter last) {
+    for (; first != last; ++first) {
+      insert(*first);
+    }
+  }
+
+  Val& operator[](const Key& k) { return IndexOp(k); }
+  Val& operator[](Key&& k) { return IndexOp(std::forward<Key>(k)); }
+
+  template <typename... Args>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    return InsertPair(std::make_pair(std::forward<Args>(args)...));
+  }
+
+  size_t erase(const Key& k) {
+    auto r = rep_.Find(k);
+    if (!r.found) return 0;
+    rep_.Erase(r.b, r.index);
+    return 1;
+  }
+  iterator erase(iterator pos) {
+    rep_.Erase(pos.b_, pos.i_);
+    ++pos;
+    return pos;
+  }
+  iterator erase(iterator pos, iterator last) {
+    for (; pos != last; ++pos) {
+      rep_.Erase(pos.b_, pos.i_);
+    }
+    return pos;
+  }
+
+  std::pair<iterator, iterator> equal_range(const Key& k) {
+    auto pos = find(k);
+    if (pos == end()) {
+      return std::make_pair(pos, pos);
+    } else {
+      auto next = pos;
+      ++next;
+      return std::make_pair(pos, next);
+    }
+  }
+  std::pair<const_iterator, const_iterator> equal_range(const Key& k) const {
+    auto pos = find(k);
+    if (pos == end()) {
+      return std::make_pair(pos, pos);
+    } else {
+      auto next = pos;
+      ++next;
+      return std::make_pair(pos, next);
+    }
+  }
+
+  bool operator==(const FlatMap& x) const {
+    if (size() != x.size()) return false;
+    for (auto& p : x) {
+      auto i = find(p.first);
+      if (i == end()) return false;
+      if (i->second != p.second) return false;
+    }
+    return true;
+  }
+  bool operator!=(const FlatMap& x) const { return !(*this == x); }
+
+  // If key exists in the table, prefetch the associated value.  This
+  // is a hint, and may have no effect.
+  void prefetch_value(const Key& key) const { rep_.Prefetch(key); }
+
+ private:
+  using Rep = internal::FlatRep<Key, Bucket, Hash, Eq>;
+
+  // Bucket stores kWidth <marker, key, value> triples.
+  // The data is organized as three parallel arrays to reduce padding.
+  struct Bucket {
+    uint8 marker[Rep::kWidth];
+
+    // Wrap keys and values in union to control construction and destruction.
+    union Storage {
+      struct {
+        Key key[Rep::kWidth];
+        Val val[Rep::kWidth];
+      };
+      Storage() {}
+      ~Storage() {}
+    } storage;
+
+    Key& key(uint32 i) {
+      DCHECK_GE(marker[i], 2);
+      return storage.key[i];
+    }
+    Val& val(uint32 i) {
+      DCHECK_GE(marker[i], 2);
+      return storage.val[i];
+    }
+    template <typename V>
+    void InitVal(uint32 i, V&& v) {
+      new (&storage.val[i]) Val(std::forward<V>(v));
+    }
+    void Destroy(uint32 i) {
+      storage.key[i].Key::~Key();
+      storage.val[i].Val::~Val();
+    }
+    void MoveFrom(uint32 i, Bucket* src, uint32 src_index) {
+      new (&storage.key[i]) Key(std::move(src->storage.key[src_index]));
+      new (&storage.val[i]) Val(std::move(src->storage.val[src_index]));
+    }
+    void CopyFrom(uint32 i, Bucket* src, uint32 src_index) {
+      new (&storage.key[i]) Key(src->storage.key[src_index]);
+      new (&storage.val[i]) Val(src->storage.val[src_index]);
+    }
+  };
+
+  template <typename Pair>
+  std::pair<iterator, bool> InsertPair(Pair&& p) {
+    return Insert(std::forward<decltype(p.first)>(p.first),
+                  std::forward<decltype(p.second)>(p.second));
+  }
+
+  template <typename K, typename V>
+  std::pair<iterator, bool> Insert(K&& k, V&& v) {
+    rep_.MaybeResize();
+    auto r = rep_.FindOrInsert(std::forward<K>(k));
+    const bool inserted = !r.found;
+    if (inserted) {
+      r.b->InitVal(r.index, std::forward<V>(v));
+    }
+    return {iterator(r.b, rep_.limit(), r.index), inserted};
+  }
+
+  template <typename K>
+  Val& IndexOp(K&& k) {
+    rep_.MaybeResize();
+    auto r = rep_.FindOrInsert(std::forward<K>(k));
+    Val* vptr = &r.b->val(r.index);
+    if (!r.found) {
+      new (vptr) Val();  // Initialize value in new slot.
+    }
+    return *vptr;
+  }
+
+  Rep rep_;
+};
+
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_FLATMAP_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/flatrep.h

@@ -0,0 +1,352 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_FLATREP_H_
+#define TENSORFLOW_TSL_LIB_GTL_FLATREP_H_
+
+#include <string.h>
+
+#include <utility>
+
+#include "absl/base/prefetch.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace gtl {
+namespace internal {
+
+// Internal representation for FlatMap and FlatSet.
+//
+// The representation is an open-addressed hash table.  Conceptually,
+// the representation is a flat array of entries.  However we
+// structure it as an array of buckets where each bucket holds
+// kWidth entries along with metadata for the kWidth entries.  The
+// metadata marker is
+//
+//  (a) kEmpty: the entry is empty
+//  (b) kDeleted: the entry has been deleted
+//  (c) other: the entry is occupied and has low-8 bits of its hash.
+//      These hash bits can be used to avoid potentially expensive
+//      key comparisons.
+//
+// FlatMap passes in a bucket that contains keys and values, FlatSet
+// passes in a bucket that does not contain values.
+template <typename Key, typename Bucket, class Hash, class Eq>
+class FlatRep {
+ public:
+  // kWidth is the number of entries stored in a bucket.
+  static constexpr uint32 kBase = 3;
+  static constexpr uint32 kWidth = (1 << kBase);
+
+  FlatRep(size_t N, const Hash& hf, const Eq& eq) : hash_(hf), equal_(eq) {
+    Init(N);
+  }
+  FlatRep(const FlatRep& src) : hash_(src.hash_), equal_(src.equal_) {
+    Init(src.size());
+    CopyEntries(src.array_, src.end_, CopyEntry());
+  }
+
+  FlatRep(FlatRep&& src)
+      // Copy rather than move src.hash_ and src.equal_.  This is necessary to
+      // leave src in a valid state -- otherwise e.g. if hash_ is an
+      // std::function, moving it would null it out.
+      : hash_(src.hash_), equal_(src.equal_) {
+    // TODO(jlebar): Init(1) still allocates some memory, so this isn't as cheap
+    // as it could be.  The fundamental problem is that we need to leave src in
+    // a valid state, and FlatRep *always* owns a nonzero amount of memory.
+    Init(1);
+    swap(src);
+  }
+
+  ~FlatRep() {
+    clear_no_resize();
+    delete[] array_;
+  }
+
+  // Simple accessors.
+  size_t size() const { return not_empty_ - deleted_; }
+  size_t bucket_count() const { return mask_ + 1; }
+  Bucket* start() const { return array_; }
+  Bucket* limit() const { return end_; }
+  const Hash& hash_function() const { return hash_; }
+  const Eq& key_eq() const { return equal_; }
+
+  // Overwrite contents of *this with contents of src.
+  void CopyFrom(const FlatRep& src) {
+    if (this != &src) {
+      clear_no_resize();
+      delete[] array_;
+      Init(src.size());
+      CopyEntries(src.array_, src.end_, CopyEntry());
+    }
+  }
+
+  void MoveFrom(FlatRep&& src) {
+    if (this != &src) {
+      swap(src);
+    }
+  }
+
+  void clear_no_resize() {
+    for (Bucket* b = array_; b != end_; b++) {
+      for (uint32 i = 0; i < kWidth; i++) {
+        if (b->marker[i] >= 2) {
+          b->Destroy(i);
+          b->marker[i] = kEmpty;
+        }
+      }
+    }
+    not_empty_ = 0;
+    deleted_ = 0;
+  }
+
+  void clear() {
+    clear_no_resize();
+    grow_ = 0;  // Consider shrinking in MaybeResize()
+    MaybeResize();
+  }
+
+  void swap(FlatRep& x) {
+    using std::swap;
+    swap(array_, x.array_);
+    swap(end_, x.end_);
+    swap(lglen_, x.lglen_);
+    swap(mask_, x.mask_);
+    swap(not_empty_, x.not_empty_);
+    swap(deleted_, x.deleted_);
+    swap(grow_, x.grow_);
+    swap(shrink_, x.shrink_);
+  }
+
+  struct SearchResult {
+    bool found;
+    Bucket* b;
+    uint32 index;
+  };
+
+  // Hash value is partitioned as follows:
+  // 1. Bottom 8 bits are stored in bucket to help speed up comparisons.
+  // 2. Next 3 bits give index inside bucket.
+  // 3. Remaining bits give bucket number.
+
+  // Find bucket/index for key k.
+  SearchResult Find(const Key& k) const {
+    size_t h = hash_(k);
+    const uint32 marker = Marker(h & 0xff);
+    size_t index = (h >> 8) & mask_;  // Holds bucket num and index-in-bucket
+    uint32 num_probes = 1;            // Needed for quadratic probing
+    while (true) {
+      uint32 bi = index & (kWidth - 1);
+      Bucket* b = &array_[index >> kBase];
+      const uint32 x = b->marker[bi];
+      if (x == marker && equal_(b->key(bi), k)) {
+        return {true, b, bi};
+      } else if (x == kEmpty) {
+        return {false, nullptr, 0};
+      }
+      index = NextIndex(index, num_probes);
+      num_probes++;
+    }
+  }
+
+  // Find bucket/index for key k, creating a new one if necessary.
+  //
+  // KeyType is a template parameter so that k's type is deduced and it
+  // becomes a universal reference which allows the key initialization
+  // below to use an rvalue constructor if available.
+  template <typename KeyType>
+  SearchResult FindOrInsert(KeyType&& k) {
+    size_t h = hash_(k);
+    const uint32 marker = Marker(h & 0xff);
+    size_t index = (h >> 8) & mask_;  // Holds bucket num and index-in-bucket
+    uint32 num_probes = 1;            // Needed for quadratic probing
+    Bucket* del = nullptr;            // First encountered deletion for kInsert
+    uint32 di = 0;
+    while (true) {
+      uint32 bi = index & (kWidth - 1);
+      Bucket* b = &array_[index >> kBase];
+      const uint32 x = b->marker[bi];
+      if (x == marker && equal_(b->key(bi), k)) {
+        return {true, b, bi};
+      } else if (!del && x == kDeleted) {
+        // Remember deleted index to use for insertion.
+        del = b;
+        di = bi;
+      } else if (x == kEmpty) {
+        if (del) {
+          // Store in the first deleted slot we encountered
+          b = del;
+          bi = di;
+          deleted_--;  // not_empty_ does not change
+        } else {
+          not_empty_++;
+        }
+        b->marker[bi] = marker;
+        new (&b->key(bi)) Key(std::forward<KeyType>(k));
+        return {false, b, bi};
+      }
+      index = NextIndex(index, num_probes);
+      num_probes++;
+    }
+  }
+
+  void Erase(Bucket* b, uint32 i) {
+    b->Destroy(i);
+    b->marker[i] = kDeleted;
+    deleted_++;
+    grow_ = 0;  // Consider shrinking on next insert
+  }
+
+  void Prefetch(const Key& k) const {
+    size_t h = hash_(k);
+    size_t index = (h >> 8) & mask_;  // Holds bucket num and index-in-bucket
+    uint32 bi = index & (kWidth - 1);
+    Bucket* b = &array_[index >> kBase];
+    absl::PrefetchToLocalCache(&b->marker[bi]);
+    absl::PrefetchToLocalCache(&b->storage.key[bi]);
+  }
+
+  inline void MaybeResize() {
+    if (not_empty_ < grow_) {
+      return;  // Nothing to do
+    }
+    if (grow_ == 0) {
+      // Special value set by erase to cause shrink on next insert.
+      if (size() >= shrink_) {
+        // Not small enough to shrink.
+        grow_ = static_cast<size_t>(bucket_count() * 0.8);
+        if (not_empty_ < grow_) return;
+      }
+    }
+    Resize(size() + 1);
+  }
+
+  void Resize(size_t N) {
+    Bucket* old = array_;
+    Bucket* old_end = end_;
+    Init(N);
+    CopyEntries(old, old_end, MoveEntry());
+    delete[] old;
+  }
+
+ private:
+  enum { kEmpty = 0, kDeleted = 1 };  // Special markers for an entry.
+
+  Hash hash_;         // User-supplied hasher
+  Eq equal_;          // User-supplied comparator
+  uint8 lglen_;       // lg(#buckets)
+  Bucket* array_;     // array of length (1 << lglen_)
+  Bucket* end_;       // Points just past last bucket in array_
+  size_t mask_;       // (# of entries in table) - 1
+  size_t not_empty_;  // Count of entries with marker != kEmpty
+  size_t deleted_;    // Count of entries with marker == kDeleted
+  size_t grow_;       // Grow array when not_empty_ >= grow_
+  size_t shrink_;     // Shrink array when size() < shrink_
+
+  // Avoid kEmpty and kDeleted markers when computing hash values to
+  // store in Bucket::marker[].
+  static uint32 Marker(uint32 hb) { return hb + (hb < 2 ? 2 : 0); }
+
+  void Init(size_t N) {
+    // Make enough room for N elements.
+    size_t lg = 0;  // Smallest table is just one bucket.
+    while (N >= 0.8 * ((1 << lg) * kWidth)) {
+      lg++;
+    }
+    const size_t n = (1 << lg);
+    Bucket* array = new Bucket[n];
+    for (size_t i = 0; i < n; i++) {
+      Bucket* b = &array[i];
+      memset(b->marker, kEmpty, kWidth);
+    }
+    const size_t capacity = (1 << lg) * kWidth;
+    lglen_ = lg;
+    mask_ = capacity - 1;
+    array_ = array;
+    end_ = array + n;
+    not_empty_ = 0;
+    deleted_ = 0;
+    grow_ = static_cast<size_t>(capacity * 0.8);
+    if (lg == 0) {
+      // Already down to one bucket; no more shrinking.
+      shrink_ = 0;
+    } else {
+      shrink_ = static_cast<size_t>(grow_ * 0.4);  // Must be less than 0.5
+    }
+  }
+
+  // Used by FreshInsert when we should copy from source.
+  struct CopyEntry {
+    inline void operator()(Bucket* dst, uint32 dsti, Bucket* src, uint32 srci) {
+      dst->CopyFrom(dsti, src, srci);
+    }
+  };
+
+  // Used by FreshInsert when we should move from source.
+  struct MoveEntry {
+    inline void operator()(Bucket* dst, uint32 dsti, Bucket* src, uint32 srci) {
+      dst->MoveFrom(dsti, src, srci);
+      src->Destroy(srci);
+      src->marker[srci] = kDeleted;
+    }
+  };
+
+  template <typename Copier>
+  void CopyEntries(Bucket* start, Bucket* end, Copier copier) {
+    for (Bucket* b = start; b != end; b++) {
+      for (uint32 i = 0; i < kWidth; i++) {
+        if (b->marker[i] >= 2) {
+          FreshInsert(b, i, copier);
+        }
+      }
+    }
+  }
+
+  // Create an entry for the key numbered src_index in *src and return
+  // its bucket/index.  Used for insertion into a fresh table.  We
+  // assume that there are no deletions, and k does not already exist
+  // in the table.
+  template <typename Copier>
+  void FreshInsert(Bucket* src, uint32 src_index, Copier copier) {
+    size_t h = hash_(src->key(src_index));
+    const uint32 marker = Marker(h & 0xff);
+    size_t index = (h >> 8) & mask_;  // Holds bucket num and index-in-bucket
+    uint32 num_probes = 1;            // Needed for quadratic probing
+    while (true) {
+      uint32 bi = index & (kWidth - 1);
+      Bucket* b = &array_[index >> kBase];
+      const uint32 x = b->marker[bi];
+      if (x == 0) {
+        b->marker[bi] = marker;
+        not_empty_++;
+        copier(b, bi, src, src_index);
+        return;
+      }
+      index = NextIndex(index, num_probes);
+      num_probes++;
+    }
+  }
+
+  inline size_t NextIndex(size_t i, uint32 num_probes) const {
+    // Quadratic probing.
+    return (i + num_probes) & mask_;
+  }
+};
+
+}  // namespace internal
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_FLATREP_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/flatset.h

@@ -0,0 +1,296 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_FLATSET_H_
+#define TENSORFLOW_TSL_LIB_GTL_FLATSET_H_
+
+#include <stddef.h>
+
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
+#include "tsl/lib/gtl/flatrep.h"
+#include "tsl/platform/hash.h"
+#include "tsl/platform/logging.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace gtl {
+
+// FlatSet<K,...> provides a set of K.
+//
+// The map is implemented using an open-addressed hash table.  A
+// single array holds entire map contents and collisions are resolved
+// by probing at a sequence of locations in the array.
+template <typename Key, class Hash = hash<Key>, class Eq = std::equal_to<Key>>
+class FlatSet {
+ private:
+  // Forward declare some internal types needed in public section.
+  struct Bucket;
+
+ public:
+  typedef Key key_type;
+  typedef Key value_type;
+  typedef Hash hasher;
+  typedef Eq key_equal;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+  FlatSet() : FlatSet(1) {}
+
+  explicit FlatSet(size_t N, const Hash& hf = Hash(), const Eq& eq = Eq())
+      : rep_(N, hf, eq) {}
+
+  FlatSet(const FlatSet& src) : rep_(src.rep_) {}
+
+  // Move constructor leaves src in a valid but unspecified state (same as
+  // std::unordered_set).
+  FlatSet(FlatSet&& src) : rep_(std::move(src.rep_)) {}
+
+  template <typename InputIter>
+  FlatSet(InputIter first, InputIter last, size_t N = 1,
+          const Hash& hf = Hash(), const Eq& eq = Eq())
+      : FlatSet(N, hf, eq) {
+    insert(first, last);
+  }
+
+  FlatSet(std::initializer_list<value_type> init, size_t N = 1,
+          const Hash& hf = Hash(), const Eq& eq = Eq())
+      : FlatSet(init.begin(), init.end(), N, hf, eq) {}
+
+  FlatSet& operator=(const FlatSet& src) {
+    rep_.CopyFrom(src.rep_);
+    return *this;
+  }
+
+  // Move-assignment operator leaves src in a valid but unspecified state (same
+  // as std::unordered_set).
+  FlatSet& operator=(FlatSet&& src) {
+    rep_.MoveFrom(std::move(src.rep_));
+    return *this;
+  }
+
+  ~FlatSet() {}
+
+  void swap(FlatSet& x) { rep_.swap(x.rep_); }
+  void clear_no_resize() { rep_.clear_no_resize(); }
+  void clear() { rep_.clear(); }
+  void reserve(size_t N) { rep_.Resize(std::max(N, size())); }
+  void rehash(size_t N) { rep_.Resize(std::max(N, size())); }
+  void resize(size_t N) { rep_.Resize(std::max(N, size())); }
+  size_t size() const { return rep_.size(); }
+  bool empty() const { return size() == 0; }
+  size_t bucket_count() const { return rep_.bucket_count(); }
+  hasher hash_function() const { return rep_.hash_function(); }
+  key_equal key_eq() const { return rep_.key_eq(); }
+
+  class const_iterator {
+   public:
+    typedef typename FlatSet::difference_type difference_type;
+    typedef typename FlatSet::value_type value_type;
+    typedef typename FlatSet::const_pointer pointer;
+    typedef typename FlatSet::const_reference reference;
+    typedef ::std::forward_iterator_tag iterator_category;
+
+    const_iterator() : b_(nullptr), end_(nullptr), i_(0) {}
+
+    // Make iterator pointing at first element at or after b.
+    const_iterator(Bucket* b, Bucket* end) : b_(b), end_(end), i_(0) {
+      SkipUnused();
+    }
+
+    // Make iterator pointing exactly at ith element in b, which must exist.
+    const_iterator(Bucket* b, Bucket* end, uint32 i)
+        : b_(b), end_(end), i_(i) {}
+
+    reference operator*() const { return key(); }
+    pointer operator->() const { return &key(); }
+    bool operator==(const const_iterator& x) const {
+      return b_ == x.b_ && i_ == x.i_;
+    }
+    bool operator!=(const const_iterator& x) const { return !(*this == x); }
+    const_iterator& operator++() {
+      DCHECK(b_ != end_);
+      i_++;
+      SkipUnused();
+      return *this;
+    }
+    const_iterator operator++(int /*indicates postfix*/) {
+      const_iterator tmp(*this);
+      ++*this;
+      return tmp;
+    }
+
+   private:
+    friend class FlatSet;
+    Bucket* b_;
+    Bucket* end_;
+    uint32 i_;
+
+    reference key() const { return b_->key(i_); }
+    void SkipUnused() {
+      while (b_ < end_) {
+        if (i_ >= Rep::kWidth) {
+          i_ = 0;
+          b_++;
+        } else if (b_->marker[i_] < 2) {
+          i_++;
+        } else {
+          break;
+        }
+      }
+    }
+  };
+
+  typedef const_iterator iterator;
+
+  iterator begin() { return iterator(rep_.start(), rep_.limit()); }
+  iterator end() { return iterator(rep_.limit(), rep_.limit()); }
+  const_iterator begin() const {
+    return const_iterator(rep_.start(), rep_.limit());
+  }
+  const_iterator end() const {
+    return const_iterator(rep_.limit(), rep_.limit());
+  }
+
+  size_t count(const Key& k) const { return rep_.Find(k).found ? 1 : 0; }
+  iterator find(const Key& k) {
+    auto r = rep_.Find(k);
+    return r.found ? iterator(r.b, rep_.limit(), r.index) : end();
+  }
+  const_iterator find(const Key& k) const {
+    auto r = rep_.Find(k);
+    return r.found ? const_iterator(r.b, rep_.limit(), r.index) : end();
+  }
+
+  std::pair<iterator, bool> insert(const Key& k) { return Insert(k); }
+  std::pair<iterator, bool> insert(Key&& k) { return Insert(std::move(k)); }
+  template <typename InputIter>
+  void insert(InputIter first, InputIter last) {
+    for (; first != last; ++first) {
+      insert(*first);
+    }
+  }
+
+  template <typename... Args>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    rep_.MaybeResize();
+    auto r = rep_.FindOrInsert(std::forward<Args>(args)...);
+    const bool inserted = !r.found;
+    return {iterator(r.b, rep_.limit(), r.index), inserted};
+  }
+
+  size_t erase(const Key& k) {
+    auto r = rep_.Find(k);
+    if (!r.found) return 0;
+    rep_.Erase(r.b, r.index);
+    return 1;
+  }
+  iterator erase(iterator pos) {
+    rep_.Erase(pos.b_, pos.i_);
+    ++pos;
+    return pos;
+  }
+  iterator erase(iterator pos, iterator last) {
+    for (; pos != last; ++pos) {
+      rep_.Erase(pos.b_, pos.i_);
+    }
+    return pos;
+  }
+
+  std::pair<iterator, iterator> equal_range(const Key& k) {
+    auto pos = find(k);
+    if (pos == end()) {
+      return std::make_pair(pos, pos);
+    } else {
+      auto next = pos;
+      ++next;
+      return std::make_pair(pos, next);
+    }
+  }
+  std::pair<const_iterator, const_iterator> equal_range(const Key& k) const {
+    auto pos = find(k);
+    if (pos == end()) {
+      return std::make_pair(pos, pos);
+    } else {
+      auto next = pos;
+      ++next;
+      return std::make_pair(pos, next);
+    }
+  }
+
+  bool operator==(const FlatSet& x) const {
+    if (size() != x.size()) return false;
+    for (const auto& elem : x) {
+      auto i = find(elem);
+      if (i == end()) return false;
+    }
+    return true;
+  }
+  bool operator!=(const FlatSet& x) const { return !(*this == x); }
+
+  // If key exists in the table, prefetch it.  This is a hint, and may
+  // have no effect.
+  void prefetch_value(const Key& key) const { rep_.Prefetch(key); }
+
+ private:
+  using Rep = internal::FlatRep<Key, Bucket, Hash, Eq>;
+
+  // Bucket stores kWidth <marker, key, value> triples.
+  // The data is organized as three parallel arrays to reduce padding.
+  struct Bucket {
+    uint8 marker[Rep::kWidth];
+
+    // Wrap keys in union to control construction and destruction.
+    union Storage {
+      Key key[Rep::kWidth];
+      Storage() {}
+      ~Storage() {}
+    } storage;
+
+    Key& key(uint32 i) {
+      DCHECK_GE(marker[i], 2);
+      return storage.key[i];
+    }
+    void Destroy(uint32 i) { storage.key[i].Key::~Key(); }
+    void MoveFrom(uint32 i, Bucket* src, uint32 src_index) {
+      new (&storage.key[i]) Key(std::move(src->storage.key[src_index]));
+    }
+    void CopyFrom(uint32 i, Bucket* src, uint32 src_index) {
+      new (&storage.key[i]) Key(src->storage.key[src_index]);
+    }
+  };
+
+  template <typename K>
+  std::pair<iterator, bool> Insert(K&& k) {
+    rep_.MaybeResize();
+    auto r = rep_.FindOrInsert(std::forward<K>(k));
+    const bool inserted = !r.found;
+    return {iterator(r.b, rep_.limit(), r.index), inserted};
+  }
+
+  Rep rep_;
+};
+
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_FLATSET_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/inlined_vector.h

@@ -0,0 +1,33 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_INLINED_VECTOR_H_
+#define TENSORFLOW_TSL_LIB_GTL_INLINED_VECTOR_H_
+
+#include "absl/container/inlined_vector.h"  // IWYU pragma: export
+// TODO(kramerb): This is kept only because lots of targets transitively depend
+// on it. Remove all targets' dependencies.
+#include "tsl/platform/macros.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace gtl {
+
+using absl::InlinedVector;
+
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_INLINED_VECTOR_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/int_type.h

@@ -0,0 +1,364 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+// #status: LEGACY
+// #category: Miscellaneous
+// #summary: Integral types; prefer util/intops/strong_int.h
+// #bugs: Infrastructure > C++ Library Team > util
+//
+// IntType is a simple template class mechanism for defining "logical"
+// integer-like class types that support many of the same functionalities
+// as native integer types, but which prevent assignment, construction, and
+// other operations from other similar integer-like types.  Essentially, the
+// template class IntType<IntTypeName, ValueType> (where ValueType assumes
+// valid scalar types such as int, uint, int32, etc) has the additional
+// property that it cannot be assigned to or constructed from other IntTypes
+// or native integer types of equal or implicitly convertible type.
+//
+// The class is useful for preventing mingling of integer variables with
+// different logical roles or units.  Unfortunately, C++ provides relatively
+// good type-safety for user-defined classes but not for integer types.  It is
+// essentially up to the user to use nice variable names and comments to prevent
+// accidental mismatches, such as confusing a user-index with a group-index or a
+// time-in-milliseconds with a time-in-seconds.  The use of typedefs are limited
+// in that regard as they do not enforce type-safety.
+//
+// USAGE -----------------------------------------------------------------------
+//
+//    DEFINE_INT_TYPE(IntTypeName, ValueType);
+//
+//  where:
+//    IntTypeName: is the desired (unique) name for the "logical" integer type.
+//    ValueType: is one of the integral types as defined by base::is_integral
+//               (see base/type_traits.h).
+//
+// DISALLOWED OPERATIONS / TYPE-SAFETY ENFORCEMENT -----------------------------
+//
+//  Consider these definitions and variable declarations:
+//    DEFINE_INT_TYPE(GlobalDocID, int64);
+//    DEFINE_INT_TYPE(LocalDocID, int64);
+//    GlobalDocID global;
+//    LocalDocID local;
+//
+//  The class IntType prevents:
+//
+//  1) Assignments of other IntTypes with different IntTypeNames.
+//
+//    global = local;                  <-- Fails to compile!
+//    local = global;                  <-- Fails to compile!
+//
+//  2) Explicit/implicit conversion from an IntType to another IntType.
+//
+//    LocalDocID l(global);            <-- Fails to compile!
+//    LocalDocID l = global;           <-- Fails to compile!
+//
+//    void GetGlobalDoc(GlobalDocID global) { }
+//    GetGlobalDoc(global);            <-- Compiles fine, types match!
+//    GetGlobalDoc(local);             <-- Fails to compile!
+//
+//  3) Implicit conversion from an IntType to a native integer type.
+//
+//    void GetGlobalDoc(int64 global) { ...
+//    GetGlobalDoc(global);            <-- Fails to compile!
+//    GetGlobalDoc(local);             <-- Fails to compile!
+//
+//    void GetLocalDoc(int32 local) { ...
+//    GetLocalDoc(global);             <-- Fails to compile!
+//    GetLocalDoc(local);              <-- Fails to compile!
+//
+//
+// SUPPORTED OPERATIONS --------------------------------------------------------
+//
+// The following operators are supported: unary: ++ (both prefix and postfix),
+// +, -, ! (logical not), ~ (one's complement); comparison: ==, !=, <, <=, >,
+// >=; numerical: +, -, *, /; assignment: =, +=, -=, /=, *=; stream: <<. Each
+// operator allows the same IntTypeName and the ValueType to be used on
+// both left- and right-hand sides.
+//
+// It also supports an accessor value() returning the stored value as ValueType,
+// and a templatized accessor value<T>() method that serves as syntactic sugar
+// for static_cast<T>(var.value()).  These accessors are useful when assigning
+// the stored value into protocol buffer fields and using it as printf args.
+//
+// The class also defines a hash functor that allows the IntType to be used
+// as key to hashable containers such as std::unordered_map and
+// std::unordered_set.
+//
+// We suggest using the IntTypeIndexedContainer wrapper around FixedArray and
+// STL vector (see int-type-indexed-container.h) if an IntType is intended to
+// be used as an index into these containers.  These wrappers are indexed in a
+// type-safe manner using IntTypes to ensure type-safety.
+//
+// NB: this implementation does not attempt to abide by or enforce dimensional
+// analysis on these scalar types.
+//
+// EXAMPLES --------------------------------------------------------------------
+//
+//    DEFINE_INT_TYPE(GlobalDocID, int64);
+//    GlobalDocID global = 3;
+//    cout << global;                      <-- Prints 3 to stdout.
+//
+//    for (GlobalDocID i(0); i < global; ++i) {
+//      cout << i;
+//    }                                    <-- Print(ln)s 0 1 2 to stdout
+//
+//    DEFINE_INT_TYPE(LocalDocID, int64);
+//    LocalDocID local;
+//    cout << local;                       <-- Prints 0 to stdout it default
+//                                             initializes the value to 0.
+//
+//    local = 5;
+//    local *= 2;
+//    LocalDocID l(local);
+//    cout << l + local;                   <-- Prints 20 to stdout.
+//
+//    GenericSearchRequest request;
+//    request.set_doc_id(global.value());  <-- Uses value() to extract the value
+//                                             from the IntType class.
+//
+// REMARKS ---------------------------------------------------------------------
+//
+// The following bad usage is permissible although discouraged.  Essentially, it
+// involves using the value*() accessors to extract the native integer type out
+// of the IntType class.  Keep in mind that the primary reason for the IntType
+// class is to prevent *accidental* mingling of similar logical integer types --
+// and not type casting from one type to another.
+//
+//  DEFINE_INT_TYPE(GlobalDocID, int64);
+//  DEFINE_INT_TYPE(LocalDocID, int64);
+//  GlobalDocID global;
+//  LocalDocID local;
+//
+//  global = local.value();                       <-- Compiles fine.
+//
+//  void GetGlobalDoc(GlobalDocID global) { ...
+//  GetGlobalDoc(local.value());                  <-- Compiles fine.
+//
+//  void GetGlobalDoc(int64 global) { ...
+//  GetGlobalDoc(local.value());                  <-- Compiles fine.
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_INT_TYPE_H_
+#define TENSORFLOW_TSL_LIB_GTL_INT_TYPE_H_
+
+#include <stddef.h>
+
+#include <functional>
+#include <iosfwd>
+#include <ostream>  // NOLINT
+#include <unordered_map>
+
+#include "tsl/platform/macros.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace gtl {
+
+template <typename IntTypeName, typename _ValueType>
+class IntType;
+
+// Defines the IntType using value_type and typedefs it to int_type_name.
+// The struct int_type_name ## _tag_ trickery is needed to ensure that a new
+// type is created per int_type_name.
+#define TSL_LIB_GTL_DEFINE_INT_TYPE(int_type_name, value_type) \
+  struct int_type_name##_tag_ {};                              \
+  typedef ::tsl::gtl::IntType<int_type_name##_tag_, value_type> int_type_name;
+
+// Holds an integer value (of type ValueType) and behaves as a ValueType by
+// exposing assignment, unary, comparison, and arithmetic operators.
+//
+// The template parameter IntTypeName defines the name for the int type and must
+// be unique within a binary (the convenient DEFINE_INT_TYPE macro at the end of
+// the file generates a unique IntTypeName).  The parameter ValueType defines
+// the integer type value (see supported list above).
+//
+// This class is NOT thread-safe.
+template <typename IntTypeName, typename _ValueType>
+class IntType {
+ public:
+  typedef _ValueType ValueType;                      // for non-member operators
+  typedef IntType<IntTypeName, ValueType> ThisType;  // Syntactic sugar.
+
+  // Note that this may change from time to time without notice.
+  struct Hasher {
+    size_t operator()(const IntType& arg) const {
+      return static_cast<size_t>(arg.value());
+    }
+  };
+
+  template <typename H>
+  friend H AbslHashValue(H h, const IntType& i) {
+    return H::combine(std::move(h), i.value());
+  }
+
+ public:
+  // Default c'tor initializing value_ to 0.
+  constexpr IntType() : value_(0) {}
+  // C'tor explicitly initializing from a ValueType.
+  constexpr explicit IntType(ValueType value) : value_(value) {}
+
+  // IntType uses the default copy constructor, destructor and assign operator.
+  // The defaults are sufficient and omitting them allows the compiler to add
+  // the move constructor/assignment.
+
+  // -- ACCESSORS --------------------------------------------------------------
+  // The class provides a value() accessor returning the stored ValueType value_
+  // as well as a templatized accessor that is just a syntactic sugar for
+  // static_cast<T>(var.value());
+  constexpr ValueType value() const { return value_; }
+
+  template <typename ValType>
+  constexpr ValType value() const {
+    return static_cast<ValType>(value_);
+  }
+
+  // -- UNARY OPERATORS --------------------------------------------------------
+  ThisType& operator++() {  // prefix ++
+    ++value_;
+    return *this;
+  }
+  const ThisType operator++(int v) {  // postfix ++
+    ThisType temp(*this);
+    ++value_;
+    return temp;
+  }
+  ThisType& operator--() {  // prefix --
+    --value_;
+    return *this;
+  }
+  const ThisType operator--(int v) {  // postfix --
+    ThisType temp(*this);
+    --value_;
+    return temp;
+  }
+
+  constexpr bool operator!() const { return value_ == 0; }
+  constexpr const ThisType operator+() const { return ThisType(value_); }
+  constexpr const ThisType operator-() const { return ThisType(-value_); }
+  constexpr const ThisType operator~() const { return ThisType(~value_); }
+
+// -- ASSIGNMENT OPERATORS ---------------------------------------------------
+// We support the following assignment operators: =, +=, -=, *=, /=, <<=, >>=
+// and %= for both ThisType and ValueType.
+#define INT_TYPE_ASSIGNMENT_OP(op)                   \
+  ThisType& operator op(const ThisType& arg_value) { \
+    value_ op arg_value.value();                     \
+    return *this;                                    \
+  }                                                  \
+  ThisType& operator op(ValueType arg_value) {       \
+    value_ op arg_value;                             \
+    return *this;                                    \
+  }
+  INT_TYPE_ASSIGNMENT_OP(+=);
+  INT_TYPE_ASSIGNMENT_OP(-=);
+  INT_TYPE_ASSIGNMENT_OP(*=);
+  INT_TYPE_ASSIGNMENT_OP(/=);
+  INT_TYPE_ASSIGNMENT_OP(<<=);  // NOLINT
+  INT_TYPE_ASSIGNMENT_OP(>>=);  // NOLINT
+  INT_TYPE_ASSIGNMENT_OP(%=);
+#undef INT_TYPE_ASSIGNMENT_OP
+
+  ThisType& operator=(ValueType arg_value) {
+    value_ = arg_value;
+    return *this;
+  }
+
+ private:
+  // The integer value of type ValueType.
+  ValueType value_;
+
+  static_assert(std::is_integral<ValueType>::value, "invalid integer type");
+} TF_PACKED;
+
+// -- NON-MEMBER STREAM OPERATORS ----------------------------------------------
+// We provide the << operator, primarily for logging purposes.  Currently, there
+// seems to be no need for an >> operator.
+template <typename IntTypeName, typename ValueType>
+std::ostream& operator<<(std::ostream& os,  // NOLINT
+                         IntType<IntTypeName, ValueType> arg) {
+  return os << arg.value();
+}
+
+// -- NON-MEMBER ARITHMETIC OPERATORS ------------------------------------------
+// We support only the +, -, *, and / operators with the same IntType and
+// ValueType types.  The reason is to allow simple manipulation on these IDs
+// when used as indices in vectors and arrays.
+//
+// NB: Although it is possible to do IntType * IntType and IntType / IntType,
+// it is probably non-sensical from a dimensionality analysis perspective.
+#define INT_TYPE_ARITHMETIC_OP(op)                                        \
+  template <typename IntTypeName, typename ValueType>                     \
+  static inline constexpr IntType<IntTypeName, ValueType> operator op(    \
+      IntType<IntTypeName, ValueType> id_1,                               \
+      IntType<IntTypeName, ValueType> id_2) {                             \
+    return IntType<IntTypeName, ValueType>(id_1.value() op id_2.value()); \
+  }                                                                       \
+  template <typename IntTypeName, typename ValueType>                     \
+  static inline constexpr IntType<IntTypeName, ValueType> operator op(    \
+      IntType<IntTypeName, ValueType> id,                                 \
+      typename IntType<IntTypeName, ValueType>::ValueType arg_val) {      \
+    return IntType<IntTypeName, ValueType>(id.value() op arg_val);        \
+  }                                                                       \
+  template <typename IntTypeName, typename ValueType>                     \
+  static inline constexpr IntType<IntTypeName, ValueType> operator op(    \
+      typename IntType<IntTypeName, ValueType>::ValueType arg_val,        \
+      IntType<IntTypeName, ValueType> id) {                               \
+    return IntType<IntTypeName, ValueType>(arg_val op id.value());        \
+  }
+INT_TYPE_ARITHMETIC_OP(+);
+INT_TYPE_ARITHMETIC_OP(-);
+INT_TYPE_ARITHMETIC_OP(*);
+INT_TYPE_ARITHMETIC_OP(/);
+INT_TYPE_ARITHMETIC_OP(<<);  // NOLINT
+INT_TYPE_ARITHMETIC_OP(>>);  // NOLINT
+INT_TYPE_ARITHMETIC_OP(%);
+#undef INT_TYPE_ARITHMETIC_OP
+
+// -- NON-MEMBER COMPARISON OPERATORS ------------------------------------------
+// Static inline comparison operators.  We allow all comparison operators among
+// the following types (OP \in [==, !=, <, <=, >, >=]:
+//   IntType<IntTypeName, ValueType> OP IntType<IntTypeName, ValueType>
+//   IntType<IntTypeName, ValueType> OP ValueType
+//   ValueType OP IntType<IntTypeName, ValueType>
+#define INT_TYPE_COMPARISON_OP(op)                               \
+  template <typename IntTypeName, typename ValueType>            \
+  static inline constexpr bool operator op(                      \
+      IntType<IntTypeName, ValueType> id_1,                      \
+      IntType<IntTypeName, ValueType> id_2) {                    \
+    return id_1.value() op id_2.value();                         \
+  }                                                              \
+  template <typename IntTypeName, typename ValueType>            \
+  static inline constexpr bool operator op(                      \
+      IntType<IntTypeName, ValueType> id,                        \
+      typename IntType<IntTypeName, ValueType>::ValueType val) { \
+    return id.value() op val;                                    \
+  }                                                              \
+  template <typename IntTypeName, typename ValueType>            \
+  static inline constexpr bool operator op(                      \
+      typename IntType<IntTypeName, ValueType>::ValueType val,   \
+      IntType<IntTypeName, ValueType> id) {                      \
+    return val op id.value();                                    \
+  }
+INT_TYPE_COMPARISON_OP(==);  // NOLINT
+INT_TYPE_COMPARISON_OP(!=);  // NOLINT
+INT_TYPE_COMPARISON_OP(<);   // NOLINT
+INT_TYPE_COMPARISON_OP(<=);  // NOLINT
+INT_TYPE_COMPARISON_OP(>);   // NOLINT
+INT_TYPE_COMPARISON_OP(>=);  // NOLINT
+#undef INT_TYPE_COMPARISON_OP
+
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_INT_TYPE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/iterator_range.h

@@ -0,0 +1,68 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+// This provides a very simple, boring adaptor for a begin and end iterator
+// into a range type. This should be used to build range views that work well
+// with range based for loops and range based constructors.
+//
+// Note that code here follows more standards-based coding conventions as it
+// is mirroring proposed interfaces for standardization.
+//
+// Converted from chandlerc@'s code to Google style by joshl@.
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_ITERATOR_RANGE_H_
+#define TENSORFLOW_TSL_LIB_GTL_ITERATOR_RANGE_H_
+
+#include <utility>
+
+namespace tsl {
+namespace gtl {
+
+// A range adaptor for a pair of iterators.
+//
+// This just wraps two iterators into a range-compatible interface. Nothing
+// fancy at all.
+template <typename IteratorT>
+class iterator_range {
+ public:
+  using value_type = decltype(*std::declval<IteratorT>());
+  using iterator = IteratorT;
+  using const_iterator = IteratorT;
+
+  iterator_range() : begin_iterator_(), end_iterator_() {}
+  iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
+      : begin_iterator_(std::move(begin_iterator)),
+        end_iterator_(std::move(end_iterator)) {}
+
+  IteratorT begin() const { return begin_iterator_; }
+  IteratorT end() const { return end_iterator_; }
+
+ private:
+  IteratorT begin_iterator_, end_iterator_;
+};
+
+// Convenience function for iterating over sub-ranges.
+//
+// This provides a bit of syntactic sugar to make using sub-ranges
+// in for loops a bit easier. Analogous to std::make_pair().
+template <class T>
+iterator_range<T> make_range(T x, T y) {
+  return iterator_range<T>(std::move(x), std::move(y));
+}
+
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_ITERATOR_RANGE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/map_util.h

@@ -0,0 +1,215 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+// This file provides utility functions for use with STL map-like data
+// structures, such as std::map and hash_map. Some functions will also work with
+// sets, such as ContainsKey().
+
+#ifndef TENSORFLOW_TSL_LIB_GTL_MAP_UTIL_H_
+#define TENSORFLOW_TSL_LIB_GTL_MAP_UTIL_H_
+
+#include <stddef.h>
+
+#include <iterator>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "tsl/lib/gtl/subtle/map_traits.h"
+
+namespace tsl {
+namespace gtl {
+
+// Returns a pointer to the const value associated with the given key if it
+// exists, or NULL otherwise.
+template <class Collection>
+const typename Collection::value_type::second_type* FindOrNull(
+    const Collection& collection,
+    const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return nullptr;
+  }
+  return &it->second;
+}
+
+// Same as above but returns a pointer to the non-const value.
+template <class Collection>
+typename Collection::value_type::second_type* FindOrNull(
+    Collection& collection,  // NOLINT
+    const typename Collection::value_type::first_type& key) {
+  typename Collection::iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return nullptr;
+  }
+  return &it->second;
+}
+
+// Returns the pointer value associated with the given key. If none is found,
+// NULL is returned. The function is designed to be used with a map of keys to
+// pointers.
+//
+// This function does not distinguish between a missing key and a key mapped
+// to a NULL value.
+template <class Collection>
+typename Collection::value_type::second_type FindPtrOrNull(
+    const Collection& collection,
+    const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return typename Collection::value_type::second_type();
+  }
+  return it->second;
+}
+
+// Returns a const reference to the value associated with the given key if it
+// exists, otherwise returns a const reference to the provided default value.
+//
+// WARNING: If a temporary object is passed as the default "value,"
+// this function will return a reference to that temporary object,
+// which will be destroyed at the end of the statement. A common
+// example: if you have a map with string values, and you pass a char*
+// as the default "value," either use the returned value immediately
+// or store it in a string (not string&).
+template <class Collection>
+const typename Collection::value_type::second_type& FindWithDefault(
+    const Collection& collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& value) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return value;
+  }
+  return it->second;
+}
+
+// Inserts the given key-value pair into the collection. Returns true if and
+// only if the key from the given pair didn't previously exist. Otherwise, the
+// value in the map is replaced with the value from the given pair.
+template <class Collection>
+bool InsertOrUpdate(Collection* const collection,
+                    const typename Collection::value_type& vt) {
+  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+  if (!ret.second) {
+    // update
+    ret.first->second = vt.second;
+    return false;
+  }
+  return true;
+}
+
+// Same as above, except that the key and value are passed separately.
+template <class Collection>
+bool InsertOrUpdate(Collection* const collection,
+                    const typename Collection::value_type::first_type& key,
+                    const typename Collection::value_type::second_type& value) {
+  return InsertOrUpdate(collection,
+                        typename Collection::value_type(key, value));
+}
+
+// Inserts the given key and value into the given collection if and only if the
+// given key did NOT already exist in the collection. If the key previously
+// existed in the collection, the value is not changed. Returns true if the
+// key-value pair was inserted; returns false if the key was already present.
+template <class Collection>
+bool InsertIfNotPresent(Collection* const collection,
+                        const typename Collection::value_type& vt) {
+  return collection->insert(vt).second;
+}
+
+// Same as above except the key and value are passed separately.
+template <class Collection>
+bool InsertIfNotPresent(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& value) {
+  return InsertIfNotPresent(collection,
+                            typename Collection::value_type(key, value));
+}
+
+// Looks up a given key and value pair in a collection and inserts the key-value
+// pair if it's not already present. Returns a reference to the value associated
+// with the key.
+template <class Collection>
+typename Collection::value_type::second_type& LookupOrInsert(
+    Collection* const collection, const typename Collection::value_type& vt) {
+  return collection->insert(vt).first->second;
+}
+
+// Same as above except the key-value are passed separately.
+template <class Collection>
+typename Collection::value_type::second_type& LookupOrInsert(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& value) {
+  return LookupOrInsert(collection,
+                        typename Collection::value_type(key, value));
+}
+
+// Saves the reverse mapping into reverse. Returns true if values could all be
+// inserted.
+template <typename M, typename ReverseM>
+bool ReverseMap(const M& m, ReverseM* reverse) {
+  bool all_unique = true;
+  for (const auto& kv : m) {
+    if (!InsertOrUpdate(reverse, kv.second, kv.first)) {
+      all_unique = false;
+    }
+  }
+  return all_unique;
+}
+
+// Like ReverseMap above, but returns its output m. Return type has to
+// be specified explicitly. Example:
+// M::M(...) : m_(...), r_(ReverseMap<decltype(r_)>(m_)) {}
+template <typename ReverseM, typename M>
+ReverseM ReverseMap(const M& m) {
+  typename std::remove_const<ReverseM>::type reverse;
+  ReverseMap(m, &reverse);
+  return reverse;
+}
+
+// Erases the m item identified by the given key, and returns the value
+// associated with that key. It is assumed that the value (i.e., the
+// mapped_type) is a pointer. Returns null if the key was not found in the
+// m.
+//
+// Examples:
+//   std::map<string, MyType*> my_map;
+//
+// One line cleanup:
+//     delete EraseKeyReturnValuePtr(&my_map, "abc");
+//
+// Use returned value:
+//     std::unique_ptr<MyType> value_ptr(
+//         EraseKeyReturnValuePtr(&my_map, "abc"));
+//     if (value_ptr.get())
+//       value_ptr->DoSomething();
+//
+template <typename Collection>
+typename Collection::value_type::second_type EraseKeyReturnValuePtr(
+    Collection* collection,
+    const typename Collection::value_type::first_type& key) {
+  auto it = collection->find(key);
+  if (it == collection->end()) return nullptr;
+  auto v = gtl::subtle::GetMapped(*it);
+  collection->erase(it);
+  return v;
+}
+
+}  // namespace gtl
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_GTL_MAP_UTIL_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/gtl/subtle/map_traits.h

@@ -0,0 +1,65 @@
+
+/* Copyright 2019 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.
+==============================================================================*/
+// Traits classes for performing uniform lookup on different map value types.
+//
+// The access is computed as follows:
+//
+//   1. If T has a `first` or `second` field, use them.
+//   2. Otherwise if it has `key()` or `value()` methods, use them.
+//   3. Otherwise the program is ill-formed.
+#ifndef TENSORFLOW_TSL_LIB_GTL_SUBTLE_MAP_TRAITS_H_
+#define TENSORFLOW_TSL_LIB_GTL_SUBTLE_MAP_TRAITS_H_
+#include <utility>
+namespace tsl {
+namespace gtl {
+namespace subtle {
+namespace internal_map_traits {
+struct Rank1 {};
+struct Rank0 : Rank1 {};
+template <class V>
+auto GetKey(V&& v, Rank0) -> decltype((std::forward<V>(v).first)) {
+  return std::forward<V>(v).first;
+}
+template <class V>
+auto GetKey(V&& v, Rank1) -> decltype(std::forward<V>(v).key()) {
+  return std::forward<V>(v).key();
+}
+template <class V>
+auto GetMapped(V&& v, Rank0) -> decltype((std::forward<V>(v).second)) {
+  return std::forward<V>(v).second;
+}
+template <class V>
+auto GetMapped(V&& v, Rank1) -> decltype(std::forward<V>(v).value()) {
+  return std::forward<V>(v).value();
+}
+}  // namespace internal_map_traits
+// Accesses the `key_type` from a `value_type`.
+template <typename V>
+auto GetKey(V&& v)
+    -> decltype(internal_map_traits::GetKey(std::forward<V>(v),
+                                            internal_map_traits::Rank0())) {
+  return internal_map_traits::GetKey(std::forward<V>(v),
+                                     internal_map_traits::Rank0());
+}
+// Accesses the `mapped_type` from a `value_type`.
+template <typename V>
+auto GetMapped(V&& v)
+    -> decltype(internal_map_traits::GetMapped(std::forward<V>(v),
+                                               internal_map_traits::Rank0())) {
+  return internal_map_traits::GetMapped(std::forward<V>(v),
+                                        internal_map_traits::Rank0());
+}
+}  // namespace subtle
+}  // namespace gtl
+}  // namespace tsl
+#endif  // TENSORFLOW_TSL_LIB_GTL_SUBTLE_MAP_TRAITS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/hash/crc32c.h

@@ -0,0 +1,69 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_HASH_CRC32C_H_
+#define TENSORFLOW_TSL_LIB_HASH_CRC32C_H_
+
+#include <stddef.h>
+
+#include "absl/crc/crc32c.h"
+#include "tsl/platform/cord.h"
+#include "tsl/platform/platform.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace crc32c {
+
+// Return the crc32c of concat(A, buf[0,size-1]) where init_crc is the
+// crc32c of some string A.  Extend() is often used to maintain the
+// crc32c of a stream of data.
+inline uint32 Extend(uint32 init_crc, const char* buf, size_t size) {
+  return static_cast<uint32>(absl::ExtendCrc32c(
+      static_cast<absl::crc32c_t>(init_crc), absl::string_view(buf, size)));
+}
+
+#if defined(TF_CORD_SUPPORT)
+extern uint32 Extend(uint32 init_crc, const absl::Cord& cord);
+#endif
+
+// Return the crc32c of data[0,n-1]
+inline uint32 Value(const char* data, size_t n) { return Extend(0, data, n); }
+
+#if defined(TF_CORD_SUPPORT)
+inline uint32 Value(const absl::Cord& cord) { return Extend(0, cord); }
+#endif
+
+static const uint32 kMaskDelta = 0xa282ead8ul;
+
+// Return a masked representation of crc.
+//
+// Motivation: it is problematic to compute the CRC of a string that
+// contains embedded CRCs.  Therefore we recommend that CRCs stored
+// somewhere (e.g., in files) should be masked before being stored.
+inline uint32 Mask(uint32 crc) {
+  // Rotate right by 15 bits and add a constant.
+  return ((crc >> 15) | (crc << 17)) + kMaskDelta;
+}
+
+// Return the crc whose masked representation is masked_crc.
+inline uint32 Unmask(uint32 masked_crc) {
+  uint32 rot = masked_crc - kMaskDelta;
+  return ((rot >> 17) | (rot << 15));
+}
+
+}  // namespace crc32c
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_HASH_CRC32C_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/histogram/histogram.h

@@ -0,0 +1,143 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_HISTOGRAM_HISTOGRAM_H_
+#define TENSORFLOW_TSL_LIB_HISTOGRAM_HISTOGRAM_H_
+
+#include <string>
+#include <vector>
+
+#include "tsl/platform/macros.h"
+#include "tsl/platform/mutex.h"
+#include "tsl/platform/thread_annotations.h"
+#include "tsl/platform/types.h"
+
+namespace tensorflow {
+class HistogramProto;
+}
+
+namespace tsl {
+using tensorflow::HistogramProto;
+
+namespace histogram {
+
+class Histogram {
+ public:
+  // Create a histogram with a default set of bucket boundaries.
+  // Buckets near zero cover very small ranges (e.g. 10^-12), and each
+  // bucket range grows by ~10% as we head away from zero.  The
+  // buckets cover the range from -DBL_MAX to DBL_MAX.
+  Histogram();
+
+  // Create a histogram with a custom set of bucket boundaries,
+  // specified in "custom_bucket_limits[0..custom_bucket_limits.size()-1]"
+  // REQUIRES: custom_bucket_limits[i] values are monotonically increasing.
+  // REQUIRES: custom_bucket_limits is not empty()
+  explicit Histogram(absl::Span<const double> custom_bucket_limits);
+
+  // Restore the state of a histogram that was previously encoded
+  // via Histogram::EncodeToProto.  Note that only the bucket boundaries
+  // generated by EncodeToProto will be restored.
+  bool DecodeFromProto(const HistogramProto& proto);
+
+  ~Histogram() {}
+
+  void Clear();
+  void Add(double value);
+
+  // Save the current state of the histogram to "*proto".  If
+  // "preserve_zero_buckets" is false, only non-zero bucket values and
+  // ranges are saved, and the bucket boundaries of zero-valued buckets
+  // are lost.
+  void EncodeToProto(HistogramProto* proto, bool preserve_zero_buckets) const;
+
+  // Return the median of the values in the histogram
+  double Median() const;
+
+  // Return the "p"th percentile [0.0..100.0] of the values in the
+  // distribution
+  double Percentile(double p) const;
+
+  // Return the average value of the distribution
+  double Average() const;
+
+  // Return the standard deviation of values in the distribution
+  double StandardDeviation() const;
+
+  // Returns a multi-line human-readable string representing the histogram
+  // contents.  Example output:
+  //   Count: 4  Average: 251.7475  StdDev: 432.02
+  //   Min: -3.0000  Median: 5.0000  Max: 1000.0000
+  //   ------------------------------------------------------
+  //   [      -5,       0 )       1  25.000%  25.000% #####
+  //   [       0,       5 )       1  25.000%  50.000% #####
+  //   [       5,      10 )       1  25.000%  75.000% #####
+  //   [    1000,   10000 )       1  25.000% 100.000% #####
+  std::string ToString() const;
+
+ private:
+  double min_;
+  double max_;
+  double num_;
+  double sum_;
+  double sum_squares_;
+
+  std::vector<double> custom_bucket_limits_;
+  absl::Span<const double> bucket_limits_;
+  std::vector<double> buckets_;
+
+  double Remap(double x, double x0, double x1, double y0, double y1) const;
+
+  Histogram(const Histogram&) = delete;
+  void operator=(const Histogram&) = delete;
+};
+
+// Wrapper around a Histogram object that is thread safe.
+//
+// All methods hold a lock while delegating to a Histogram object owned by the
+// ThreadSafeHistogram instance.
+//
+// See Histogram for documentation of the methods.
+class ThreadSafeHistogram {
+ public:
+  ThreadSafeHistogram() {}
+  explicit ThreadSafeHistogram(absl::Span<const double> custom_bucket_limits)
+      : histogram_(custom_bucket_limits) {}
+  bool DecodeFromProto(const HistogramProto& proto);
+
+  ~ThreadSafeHistogram() {}
+
+  void Clear();
+
+  // TODO(touts): It might be a good idea to provide a AddN(<many values>)
+  // method to avoid grabbing/releasing the lock when adding many values.
+  void Add(double value);
+
+  void EncodeToProto(HistogramProto* proto, bool preserve_zero_buckets) const;
+  double Median() const;
+  double Percentile(double p) const;
+  double Average() const;
+  double StandardDeviation() const;
+  std::string ToString() const;
+
+ private:
+  mutable mutex mu_;
+  Histogram histogram_ TF_GUARDED_BY(mu_);
+};
+
+}  // namespace histogram
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_HISTOGRAM_HISTOGRAM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/block.h

@@ -0,0 +1,57 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_BLOCK_H_
+#define TENSORFLOW_TSL_LIB_IO_BLOCK_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tsl/lib/io/iterator.h"
+
+namespace tsl {
+namespace table {
+
+struct BlockContents;
+
+class Block {
+ public:
+  // Initialize the block with the specified contents.
+  explicit Block(const BlockContents& contents);
+
+  ~Block();
+
+  size_t size() const { return size_; }
+  Iterator* NewIterator();
+
+ private:
+  uint32 NumRestarts() const;
+
+  const char* data_;
+  size_t size_;
+  uint32 restart_offset_;  // Offset in data_ of restart array
+  bool owned_;             // Block owns data_[]
+
+  // No copying allowed
+  Block(const Block&);
+  void operator=(const Block&);
+
+  class Iter;
+};
+
+}  // namespace table
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_BLOCK_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/block_builder.h

@@ -0,0 +1,70 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_BLOCK_BUILDER_H_
+#define TENSORFLOW_TSL_LIB_IO_BLOCK_BUILDER_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+#include "tsl/platform/stringpiece.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace table {
+
+struct Options;
+
+class BlockBuilder {
+ public:
+  explicit BlockBuilder(const Options* options);
+
+  // Reset the contents as if the BlockBuilder was just constructed.
+  void Reset();
+
+  // REQUIRES: Finish() has not been called since the last call to Reset().
+  // REQUIRES: key is larger than any previously added key
+  void Add(const StringPiece& key, const StringPiece& value);
+
+  // Finish building the block and return a slice that refers to the
+  // block contents.  The returned slice will remain valid for the
+  // lifetime of this builder or until Reset() is called.
+  StringPiece Finish();
+
+  // Returns an estimate of the current (uncompressed) size of the block
+  // we are building.
+  size_t CurrentSizeEstimate() const;
+
+  // Return true iff no entries have been added since the last Reset()
+  bool empty() const { return buffer_.empty(); }
+
+ private:
+  const Options* options_;
+  string buffer_;                 // Destination buffer
+  std::vector<uint32> restarts_;  // Restart points
+  int counter_;                   // Number of entries emitted since restart
+  bool finished_;                 // Has Finish() been called?
+  string last_key_;
+
+  // No copying allowed
+  BlockBuilder(const BlockBuilder&);
+  void operator=(const BlockBuilder&);
+};
+
+}  // namespace table
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_BLOCK_BUILDER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/buffered_file.h

@@ -0,0 +1,115 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_BUFFERED_FILE_H_
+#define TENSORFLOW_TSL_LIB_IO_BUFFERED_FILE_H_
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "tsl/lib/hash/crc32c.h"
+#include "tsl/platform/cord.h"
+#include "tsl/platform/file_system.h"
+#include "tsl/platform/status.h"
+
+namespace tsl {
+class BufferedWritableFile : public WritableFile {
+ public:
+  explicit BufferedWritableFile(std::unique_ptr<WritableFile> file,
+                                int64_t buffer_size = kDefaultBufferSize)
+      : file_(std::move(file)) {
+    buffer_.resize(buffer_size);
+  }
+  ~BufferedWritableFile() override { Close().IgnoreError(); }
+
+  Status Append(StringPiece str_data) override {
+    int64_t bytes_left = str_data.size();
+    const char* data = str_data.data();
+
+    while (bytes_left > 0) {
+      int64_t append_bytes = std::min(
+          static_cast<int64_t>(buffer_.size() - buffer_pos_), bytes_left);
+
+      // Create a copy of the current segment and compute the checksum. We
+      // compute the checksum on the copied section in case the underlying
+      // `data` buffer changes while we are writing.
+      std::copy_n(data, append_bytes, buffer_.begin() + buffer_pos_);
+      crc32_ = crc32c::Extend(crc32_, &buffer_[buffer_pos_], append_bytes);
+      buffer_pos_ += append_bytes;
+      if (buffer_pos_ == buffer_.size()) {
+        TF_RETURN_IF_ERROR(file_->Append(buffer_));
+        buffer_pos_ = 0;
+      }
+      data = data + append_bytes;
+      bytes_left -= append_bytes;
+    }
+
+    return OkStatus();
+  }
+
+  Status Append(const absl::Cord& data) override {
+    for (absl::string_view fragment : data.Chunks()) {
+      TF_RETURN_IF_ERROR(Append(fragment));
+    }
+    return OkStatus();
+  }
+
+  Status Close() override {
+    TF_RETURN_IF_ERROR(Flush());
+    return file_->Close();
+  }
+
+  Status Flush() override {
+    if (buffer_pos_ > 0) {
+      TF_RETURN_IF_ERROR(file_->Append(StringPiece(&buffer_[0], buffer_pos_)));
+      buffer_pos_ = 0;
+    }
+    return file_->Flush();
+  }
+
+  tsl::Status Tell(int64_t* position) override {
+    int64_t bytes_written;
+    tsl::Status status = file_->Tell(&bytes_written);
+    if (status.ok()) {
+      *position = bytes_written + buffer_pos_;
+      return OkStatus();
+    } else {
+      return status;
+    }
+  }
+
+  Status Sync() override { return file_->Sync(); }
+
+  // For compatibilty with the TensorBundle writer, we expose CRC32 checksums.
+  uint32_t crc32() const { return crc32_; }
+  void reset_crc32() { crc32_ = 0; }
+
+ private:
+  static constexpr int64_t kDefaultBufferSize = 1048576;
+
+  std::string buffer_;
+  int64_t buffer_pos_ = 0;
+
+  std::unique_ptr<WritableFile> file_;
+  uint32_t crc32_ = 0;
+
+  BufferedWritableFile(const BufferedWritableFile&) = delete;
+  void operator=(const BufferedWritableFile&) = delete;
+};
+
+}  // namespace tsl
+#endif  // TENSORFLOW_TSL_LIB_IO_BUFFERED_FILE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/buffered_inputstream.h

@@ -0,0 +1,127 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_BUFFERED_INPUTSTREAM_H_
+#define TENSORFLOW_TSL_LIB_IO_BUFFERED_INPUTSTREAM_H_
+
+#include <string>
+
+#include "tsl/lib/io/inputstream_interface.h"
+#include "tsl/platform/file_system.h"
+
+namespace tsl {
+namespace io {
+
+// Provides a buffer on top of an InputStreamInterface. A single instance of
+// BufferedInputStream is NOT safe for concurrent use by multiple threads.
+class BufferedInputStream : public InputStreamInterface {
+ public:
+  // Does not take ownership of input_stream unless owns_input_stream is set
+  // to true. input_stream must outlive *this then.
+  // TODO(rohanj): Remove owns_input_stream once the constructor below is
+  // removed.
+  BufferedInputStream(InputStreamInterface* input_stream, size_t buffer_bytes,
+                      bool owns_input_stream = false);
+
+  // For backwards compatibility, expose an interface that is similar to what
+  // InputBuffer exposes. Does not take ownership of file. file must outlive
+  // *this. This will be removed once we migrate all uses of this class to the
+  // constructor above.
+  BufferedInputStream(RandomAccessFile* file, size_t buffer_bytes);
+
+  ~BufferedInputStream() override;
+
+  Status ReadNBytes(int64_t bytes_to_read, tstring* result) override;
+
+  Status SkipNBytes(int64_t bytes_to_skip) override;
+
+  int64_t Tell() const override;
+
+  // Seek to this offset within the file.
+  //
+  // If we seek to somewhere within our pre-buffered data, we will re-use what
+  // data we can.  Otherwise, Seek() throws out the current buffer and the next
+  // read will trigger an underlying read.
+  //
+  // Note: When seeking backwards in a stream, this implementation uses
+  // Reset() + SkipNBytes(), so its performance will be dependent
+  // largely on the performance of SkipNBytes().
+  Status Seek(int64_t position);
+
+  // Read one text line of data into "*result" until end-of-file or a
+  // \n is read.  (The \n is not included in the result.)  Overwrites
+  // any existing data in *result.
+  //
+  // If successful, returns OK.  If we are already at the end of the
+  // file, we return an OUT_OF_RANGE error.  Otherwise, we return
+  // some other non-OK status.
+  Status ReadLine(std::string* result);
+  Status ReadLine(tstring* result);
+
+  // Returns one text line of data until end-of-file or a '\n' is read. The '\n'
+  // is included in the result.
+  // This method is a substitute for ReadLine() when called from Python which is
+  // the expectation in the python File::readline() API.
+  // Also, '\0's are treated like any other character within the line and given
+  // no special treatment.
+  std::string ReadLineAsString();
+
+  // Skip one text line of data.
+  //
+  // If successful, returns OK.  If we are already at the end of the
+  // file, we return an OUT_OF_RANGE error.  Otherwise, we return
+  // some other non-OK status.
+  Status SkipLine();
+
+  // Reads the entire contents of the file into *result.
+  //
+  // Note: the amount of memory used by this function call is unbounded, so only
+  // use in ops that expect that behavior.
+  template <typename T>
+  Status ReadAll(T* result);
+
+  Status Reset() override;
+
+ private:
+  Status FillBuffer();
+  template <typename StringType>
+  Status ReadLineHelper(StringType* result, bool include_eol);
+
+  InputStreamInterface* input_stream_;  // not owned.
+  size_t size_;                         // buffer size.
+  tstring buf_;                         // the buffer itself.
+  // buf_[pos_, limit_) holds the valid "read ahead" data in the file.
+  size_t pos_ = 0;    // current position in buf_.
+  size_t limit_ = 0;  // just past the end of valid data in buf_.
+  bool owns_input_stream_ = false;
+  // When EoF is reached, file_status_ contains the status to skip unnecessary
+  // buffer allocations.
+  Status file_status_ = OkStatus();
+
+  BufferedInputStream(const BufferedInputStream&) = delete;
+  void operator=(const BufferedInputStream&) = delete;
+};
+
+// Explicit instantiations defined in buffered_inputstream.cc.
+#ifndef SWIG
+extern template Status BufferedInputStream::ReadAll<std::string>(
+    std::string* result);
+extern template Status BufferedInputStream::ReadAll<tstring>(tstring* result);
+#endif  // SWIG
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_BUFFERED_INPUTSTREAM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/cache.h

@@ -0,0 +1,127 @@
+/* Copyright 2020 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_CACHE_H_
+#define TENSORFLOW_TSL_LIB_IO_CACHE_H_
+
+#include <cstdint>
+
+#include "tsl/platform/stringpiece.h"
+
+// A Cache is an interface that maps keys to values.  It has internal
+// synchronization and may be safely accessed concurrently from
+// multiple threads.  It may automatically evict entries to make room
+// for new entries.  Values have a specified charge against the cache
+// capacity.  For example, a cache where the values are variable
+// length strings, may use the length of the string as the charge for
+// the string.
+//
+// A builtin cache implementation with a least-recently-used eviction
+// policy is provided.  Clients may use their own implementations if
+// they want something more sophisticated (like scan-resistance, a
+// custom eviction policy, variable cache sizing, etc.)
+
+namespace tsl {
+
+using Slice = StringPiece;
+
+namespace table {
+
+class Cache;
+
+// Create a new cache with a fixed size capacity.  This implementation
+// of Cache uses a least-recently-used eviction policy.
+Cache* NewLRUCache(size_t capacity);
+
+class Cache {
+ public:
+  Cache() = default;
+
+  Cache(const Cache&) = delete;
+  Cache& operator=(const Cache&) = delete;
+
+  // Destroys all existing entries by calling the "deleter"
+  // function that was passed to the constructor.
+  virtual ~Cache();
+
+  // Opaque handle to an entry stored in the cache.
+  struct Handle {};
+
+  // Insert a mapping from key->value into the cache and assign it
+  // the specified charge against the total cache capacity.
+  //
+  // Returns a handle that corresponds to the mapping.  The caller
+  // must call this->Release(handle) when the returned mapping is no
+  // longer needed.
+  //
+  // When the inserted entry is no longer needed, the key and
+  // value will be passed to "deleter".
+  virtual Handle* Insert(const Slice& key, void* value, size_t charge,
+                         void (*deleter)(const Slice& key, void* value)) = 0;
+
+  // If the cache has no mapping for "key", returns nullptr.
+  //
+  // Else return a handle that corresponds to the mapping.  The caller
+  // must call this->Release(handle) when the returned mapping is no
+  // longer needed.
+  virtual Handle* Lookup(const Slice& key) = 0;
+
+  // Release a mapping returned by a previous Lookup().
+  // REQUIRES: handle must not have been released yet.
+  // REQUIRES: handle must have been returned by a method on *this.
+  virtual void Release(Handle* handle) = 0;
+
+  // Return the value encapsulated in a handle returned by a
+  // successful Lookup().
+  // REQUIRES: handle must not have been released yet.
+  // REQUIRES: handle must have been returned by a method on *this.
+  virtual void* Value(Handle* handle) = 0;
+
+  // If the cache contains entry for key, erase it.  Note that the
+  // underlying entry will be kept around until all existing handles
+  // to it have been released.
+  virtual void Erase(const Slice& key) = 0;
+
+  // Return a new numeric id.  May be used by multiple clients who are
+  // sharing the same cache to partition the key space.  Typically the
+  // client will allocate a new id at startup and prepend the id to
+  // its cache keys.
+  virtual uint64_t NewId() = 0;
+
+  // Remove all cache entries that are not actively in use.  Memory-constrained
+  // applications may wish to call this method to reduce memory usage.
+  // Default implementation of Prune() does nothing.  Subclasses are strongly
+  // encouraged to override the default implementation.  A future release of
+  // leveldb may change Prune() to a pure abstract method.
+  virtual void Prune() {}
+
+  // Return an estimate of the combined charges of all elements stored in the
+  // cache.
+  virtual size_t TotalCharge() const = 0;
+
+ private:
+  void LRU_Remove(Handle* e);
+  void LRU_Append(Handle* e);
+  void Unref(Handle* e);
+
+  struct Rep;
+  Rep* rep_;
+};
+
+}  // namespace table
+
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_CACHE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/compression.h

@@ -0,0 +1,32 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_COMPRESSION_H_
+#define TENSORFLOW_TSL_LIB_IO_COMPRESSION_H_
+
+namespace tsl {
+namespace io {
+namespace compression {
+
+extern const char kNone[];
+extern const char kGzip[];
+extern const char kSnappy[];
+extern const char kZlib[];
+
+}  // namespace compression
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_COMPRESSION_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/format.h

@@ -0,0 +1,113 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_FORMAT_H_
+#define TENSORFLOW_TSL_LIB_IO_FORMAT_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "tsl/lib/io/table_builder.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/stringpiece.h"
+
+namespace tsl {
+class RandomAccessFile;
+
+namespace table {
+
+class Block;
+
+// BlockHandle is a pointer to the extent of a file that stores a data
+// block or a meta block.
+class BlockHandle {
+ public:
+  BlockHandle();
+
+  // The offset of the block in the file.
+  uint64 offset() const { return offset_; }
+  void set_offset(uint64 offset) { offset_ = offset; }
+
+  // The size of the stored block
+  uint64 size() const { return size_; }
+  void set_size(uint64 size) { size_ = size; }
+
+  void EncodeTo(string* dst) const;
+  Status DecodeFrom(StringPiece* input);
+
+  // Maximum encoding length of a BlockHandle
+  enum { kMaxEncodedLength = 10 + 10 };
+
+ private:
+  uint64 offset_;
+  uint64 size_;
+};
+
+// Footer encapsulates the fixed information stored at the tail
+// end of every table file.
+class Footer {
+ public:
+  Footer() {}
+
+  // The block handle for the metaindex block of the table
+  const BlockHandle& metaindex_handle() const { return metaindex_handle_; }
+  void set_metaindex_handle(const BlockHandle& h) { metaindex_handle_ = h; }
+
+  // The block handle for the index block of the table
+  const BlockHandle& index_handle() const { return index_handle_; }
+  void set_index_handle(const BlockHandle& h) { index_handle_ = h; }
+
+  void EncodeTo(string* dst) const;
+  Status DecodeFrom(StringPiece* input);
+
+  // Encoded length of a Footer.  Note that the serialization of a
+  // Footer will always occupy exactly this many bytes.  It consists
+  // of two block handles and a magic number.
+  enum { kEncodedLength = 2 * BlockHandle::kMaxEncodedLength + 8 };
+
+ private:
+  BlockHandle metaindex_handle_;
+  BlockHandle index_handle_;
+};
+
+// kTableMagicNumber was picked by running
+//    echo http://code.google.com/p/leveldb/ | sha1sum
+// and taking the leading 64 bits.
+static const uint64 kTableMagicNumber = 0xdb4775248b80fb57ull;
+
+// 1-byte type + 32-bit crc
+static const size_t kBlockTrailerSize = 5;
+
+struct BlockContents {
+  StringPiece data;     // Actual contents of data
+  bool cacheable;       // True iff data can be cached
+  bool heap_allocated;  // True iff caller should delete[] data.data()
+};
+
+// Read the block identified by "handle" from "file".  On failure
+// return non-OK.  On success fill *result and return OK.
+extern Status ReadBlock(RandomAccessFile* file, const BlockHandle& handle,
+                        BlockContents* result);
+
+// Implementation details follow.  Clients should ignore,
+
+inline BlockHandle::BlockHandle()
+    : offset_(~static_cast<uint64>(0)), size_(~static_cast<uint64>(0)) {}
+
+}  // namespace table
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_FORMAT_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/inputbuffer.h

@@ -0,0 +1,151 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_INPUTBUFFER_H_
+#define TENSORFLOW_TSL_LIB_IO_INPUTBUFFER_H_
+
+#include <string>
+
+#include "tsl/platform/coding.h"
+#include "tsl/platform/env.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace io {
+
+// An InputBuffer provides a buffer on top of a RandomAccessFile.
+// A given instance of an InputBuffer is NOT safe for concurrent use
+// by multiple threads
+class InputBuffer {
+ public:
+  // Create an InputBuffer for "file" with a buffer size of
+  // "buffer_bytes" bytes.  'file' must outlive *this.
+  InputBuffer(RandomAccessFile* file, size_t buffer_bytes);
+  ~InputBuffer();
+
+  // Read one text line of data into "*result" until end-of-file or a
+  // \n is read.  (The \n is not included in the result.)  Overwrites
+  // any existing data in *result.
+  //
+  // If successful, returns OK.  If we are already at the end of the
+  // file, we return an OUT_OF_RANGE error.  Otherwise, we return
+  // some other non-OK status.
+  template <typename T>
+  Status ReadLine(T* result);
+
+  // Reads bytes_to_read bytes into *result, overwriting *result.
+  //
+  // If successful, returns OK.  If we there are not enough bytes to
+  // read before the end of the file, we return an OUT_OF_RANGE error.
+  // Otherwise, we return some other non-OK status.
+  Status ReadNBytes(int64_t bytes_to_read, std::string* result);
+
+  // An overload that writes to char*.  Caller must ensure result[0,
+  // bytes_to_read) is valid to be overwritten.  Returns OK iff "*bytes_read ==
+  // bytes_to_read".
+  Status ReadNBytes(int64_t bytes_to_read, char* result, size_t* bytes_read);
+
+  // Reads a single varint32.
+  Status ReadVarint32(uint32* result);
+
+  // Reads a single varint64.
+  Status ReadVarint64(uint64* result);
+
+  // Like ReadNBytes() without returning the bytes read.
+  Status SkipNBytes(int64_t bytes_to_skip);
+
+  // Seek to this offset within the file.
+  //
+  // If we seek to somewhere within our pre-buffered data, we will re-use what
+  // data we can.  Otherwise, Seek() throws out the current buffer and the next
+  // read will trigger a File::Read().
+  Status Seek(int64_t position);
+
+  // Provides a hint about future reads, which may improve their performance.
+  Status Hint(int64_t bytes_to_read);
+
+  // Returns the position in the file.
+  int64_t Tell() const { return file_pos_ - (limit_ - pos_); }
+
+  // Returns the underlying RandomAccessFile.
+  RandomAccessFile* file() const { return file_; }
+
+ private:
+  Status FillBuffer();
+
+  // Internal slow-path routine used by ReadVarint32().
+  Status ReadVarint32Fallback(uint32* result);
+
+  // Internal slow-path routine used by ReadVarint64().
+  Status ReadVarint64Fallback(uint64* result);
+
+  // Helper method for reading a varint which can span at max `max_bytes`.
+  // If the varint is longer, a DataLoss error status is returned.
+  // If end of file is reached while reading, OutOfRange error is returned.
+  template <typename T>
+  Status ReadVarintFallback(T* result, int max_bytes);
+
+  RandomAccessFile* file_;  // Not owned
+  int64_t file_pos_;        // Next position to read from in "file_"
+  size_t size_;             // Size of "buf_"
+  char* buf_;               // The buffer itself
+  // [pos_,limit_) hold the "limit_ - pos_" bytes just before "file_pos_"
+  char* pos_;    // Current position in "buf"
+  char* limit_;  // Just past end of valid data in "buf"
+
+  InputBuffer(const InputBuffer&) = delete;
+  void operator=(const InputBuffer&) = delete;
+};
+
+// Implementation details.
+
+// Explicit instantiations defined in inputbuffer.cc.
+extern template Status InputBuffer::ReadLine<std::string>(std::string* result);
+extern template Status InputBuffer::ReadLine<tstring>(tstring* result);
+
+// Inlined for performance.
+inline Status InputBuffer::ReadVarint32(uint32* result) {
+  if (pos_ + core::kMaxVarint32Bytes <= limit_) {
+    // Fast path: directly parse from buffered data.
+    // Reads strictly from the range [pos_, limit_).
+    const char* offset = core::GetVarint32Ptr(pos_, limit_, result);
+    if (offset == nullptr) return errors::OutOfRange("Parsed past limit.");
+    pos_ = const_cast<char*>(offset);
+    return OkStatus();
+  } else {
+    return ReadVarint32Fallback(result);
+  }
+}
+
+// Inlined for performance.
+inline Status InputBuffer::ReadVarint64(uint64* result) {
+  if (pos_ + core::kMaxVarint64Bytes <= limit_) {
+    // Fast path: directly parse from buffered data.
+    // Reads strictly from the range [pos_, limit_).
+    const char* offset = core::GetVarint64Ptr(pos_, limit_, result);
+    if (offset == nullptr) return errors::OutOfRange("Parsed past limit.");
+    pos_ = const_cast<char*>(offset);
+    return OkStatus();
+  } else {
+    return ReadVarint64Fallback(result);
+  }
+}
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_INPUTBUFFER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/inputstream_interface.h

@@ -0,0 +1,70 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_INPUTSTREAM_INTERFACE_H_
+#define TENSORFLOW_TSL_LIB_IO_INPUTSTREAM_INTERFACE_H_
+
+#include <string>
+
+#include "tsl/platform/cord.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace io {
+
+// An interface that defines input streaming operations.
+class InputStreamInterface {
+ public:
+  InputStreamInterface() {}
+  virtual ~InputStreamInterface() {}
+
+  // Reads the next bytes_to_read from the file. Typical return codes:
+  //  * OK - in case of success.
+  //  * OUT_OF_RANGE - not enough bytes remaining before end of file.
+  virtual Status ReadNBytes(int64_t bytes_to_read, tstring* result) = 0;
+
+#if defined(TF_CORD_SUPPORT)
+  // Reads the next bytes_to_read from the file. Typical return codes:
+  //  * OK - in case of success.
+  //  * OUT_OF_RANGE - not enough bytes remaining before end of file.
+  virtual Status ReadNBytes(int64_t bytes_to_read, absl::Cord* cord) {
+    return errors::Unimplemented(
+        "ReadNBytes(int64, absl::Cord*) is not implemented.");
+  }
+#endif
+
+  // Skips bytes_to_skip before next ReadNBytes. bytes_to_skip should be >= 0.
+  // Typical return codes:
+  //  * OK - in case of success.
+  //  * OUT_OF_RANGE - not enough bytes remaining before end of file.
+  virtual Status SkipNBytes(int64_t bytes_to_skip);
+
+  // Return the offset of the current byte relative to the beginning of the
+  // file.
+  // If we Skip / Read beyond the end of the file, this should return the length
+  // of the file.
+  // If there are any errors, this must return -1.
+  virtual int64_t Tell() const = 0;
+
+  // Resets the stream to the beginning.
+  virtual Status Reset() = 0;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_INPUTSTREAM_INTERFACE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/iterator.h

@@ -0,0 +1,104 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+// An iterator yields a sequence of key/value pairs from a source.
+// The following class defines the interface.  Multiple implementations
+// are provided by this library.  In particular, iterators are provided
+// to access the contents of a Table or a DB.
+//
+// Multiple threads can invoke const methods on an Iterator without
+// external synchronization, but if any of the threads may call a
+// non-const method, all threads accessing the same Iterator must use
+// external synchronization.
+
+#ifndef TENSORFLOW_TSL_LIB_IO_ITERATOR_H_
+#define TENSORFLOW_TSL_LIB_IO_ITERATOR_H_
+
+#include "tsl/platform/status.h"
+#include "tsl/platform/stringpiece.h"
+
+namespace tsl {
+namespace table {
+
+class Iterator {
+ public:
+  Iterator();
+  virtual ~Iterator();
+
+  // An iterator is either positioned at a key/value pair, or
+  // not valid.  This method returns true iff the iterator is valid.
+  virtual bool Valid() const = 0;
+
+  // Position at the first key in the source.  The iterator is Valid()
+  // after this call iff the source is not empty.
+  virtual void SeekToFirst() = 0;
+
+  // Position at the first key in the source that is at or past target.
+  // The iterator is Valid() after this call iff the source contains
+  // an entry that comes at or past target.
+  virtual void Seek(const StringPiece& target) = 0;
+
+  // Moves to the next entry in the source.  After this call, Valid() is
+  // true iff the iterator was not positioned at the last entry in the source.
+  // REQUIRES: Valid()
+  virtual void Next() = 0;
+
+  // Return the key for the current entry.  The underlying storage for
+  // the returned slice is valid only until the next modification of
+  // the iterator.
+  // REQUIRES: Valid()
+  virtual StringPiece key() const = 0;
+
+  // Return the value for the current entry.  The underlying storage for
+  // the returned slice is valid only until the next modification of
+  // the iterator.
+  // REQUIRES: Valid()
+  virtual StringPiece value() const = 0;
+
+  // If an error has occurred, return it.  Else return an ok status.
+  virtual Status status() const = 0;
+
+  // Clients are allowed to register function/arg1/arg2 triples that
+  // will be invoked when this iterator is destroyed.
+  //
+  // Note that unlike all of the preceding methods, this method is
+  // not abstract and therefore clients should not override it.
+  typedef void (*CleanupFunction)(void* arg1, void* arg2);
+  void RegisterCleanup(CleanupFunction function, void* arg1, void* arg2);
+
+ private:
+  struct Cleanup {
+    CleanupFunction function;
+    void* arg1;
+    void* arg2;
+    Cleanup* next;
+  };
+  Cleanup cleanup_;
+
+  // No copying allowed
+  Iterator(const Iterator&);
+  void operator=(const Iterator&);
+};
+
+// Return an empty iterator (yields nothing).
+extern Iterator* NewEmptyIterator();
+
+// Return an empty iterator with the specified status.
+extern Iterator* NewErrorIterator(const Status& status);
+
+}  // namespace table
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_ITERATOR_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/proto_encode_helper.h

@@ -0,0 +1,99 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_PROTO_ENCODE_HELPER_H_
+#define TENSORFLOW_TSL_LIB_IO_PROTO_ENCODE_HELPER_H_
+
+#include "tsl/platform/coding.h"
+#include "tsl/platform/logging.h"
+#include "tsl/platform/protobuf.h"
+#include "tsl/platform/stringpiece.h"
+
+// A helper class for appending various kinds of values in protocol
+// buffer encoding format to a buffer.  The client gives a pointer to
+// a buffer and a maximum size guarantee for the number of bytes they
+// will add to this buffer.
+namespace tsl {
+namespace io {
+
+class ProtoEncodeHelper {
+ public:
+  ProtoEncodeHelper(char* buf, int max_size)
+      : base_(buf), p_(buf), limit_(base_ + max_size) {}
+
+  ~ProtoEncodeHelper() {
+    // Make sure callers didn't do operations that went over max_size promised
+    DCHECK_LE(p_, limit_);
+  }
+
+  const char* data() const { return base_; }
+  size_t size() const { return p_ - base_; }
+
+  void WriteUint64(int tag, uint64 v) {
+    Encode32(combine(tag, WIRETYPE_VARINT));
+    Encode64(v);
+  }
+  void WriteBool(int tag, bool v) {
+    Encode32(combine(tag, WIRETYPE_VARINT));
+    EncodeBool(v);
+  }
+  void WriteString(int tag, StringPiece v) {
+    Encode32(combine(tag, WIRETYPE_LENGTH_DELIMITED));
+    Encode32(v.size());
+    EncodeBytes(v.data(), v.size());
+  }
+  void WriteVarlengthBeginning(int tag, uint32 len) {
+    Encode32(combine(tag, WIRETYPE_LENGTH_DELIMITED));
+    Encode32(len);
+  }
+  void WriteRawBytes(StringPiece v) { EncodeBytes(v.data(), v.size()); }
+
+ private:
+  // Note: this module's behavior must match the protocol buffer wire encoding
+  // format.
+  enum {
+    WIRETYPE_VARINT = 0,
+    WIRETYPE_LENGTH_DELIMITED = 2,
+  };
+  static uint32 combine(uint32 tag, uint32 type) { return ((tag << 3) | type); }
+  inline void Encode32(uint32 v) {
+    if (v < 128) {
+      // Fast path for single-byte values.  Many of the calls will use a
+      // constant value for v, so the comparison will get optimized away
+      // when Encode32 is inlined into the caller.
+      *p_ = v;
+      p_++;
+    } else {
+      p_ = core::EncodeVarint32(p_, v);
+    }
+  }
+  void Encode64(uint64 v) { p_ = core::EncodeVarint64(p_, v); }
+  void EncodeBool(bool v) {
+    *p_ = (v ? 1 : 0);  // Equal to varint32 encoding of 0 or 1
+    p_++;
+  }
+  void EncodeBytes(const char* bytes, int N) {
+    memcpy(p_, bytes, N);
+    p_ += N;
+  }
+
+  char* base_;
+  char* p_;
+  char* limit_;  // Just for CHECKs
+};
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_PROTO_ENCODE_HELPER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/random_inputstream.h

@@ -0,0 +1,62 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_RANDOM_INPUTSTREAM_H_
+#define TENSORFLOW_TSL_LIB_IO_RANDOM_INPUTSTREAM_H_
+
+#include "tsl/lib/io/inputstream_interface.h"
+#include "tsl/platform/cord.h"
+#include "tsl/platform/file_system.h"
+
+namespace tsl {
+namespace io {
+
+// Wraps a RandomAccessFile in an InputStreamInterface. A given instance of
+// RandomAccessInputStream is NOT safe for concurrent use by multiple threads.
+class RandomAccessInputStream : public InputStreamInterface {
+ public:
+  // Does not take ownership of 'file' unless owns_file is set to true. 'file'
+  // must outlive *this.
+  RandomAccessInputStream(RandomAccessFile* file, bool owns_file = false);
+
+  ~RandomAccessInputStream();
+
+  Status ReadNBytes(int64_t bytes_to_read, tstring* result) override;
+
+#if defined(TF_CORD_SUPPORT)
+  Status ReadNBytes(int64_t bytes_to_read, absl::Cord* result) override;
+#endif
+
+  Status SkipNBytes(int64_t bytes_to_skip) override;
+
+  int64_t Tell() const override;
+
+  Status Seek(int64_t position) {
+    pos_ = position;
+    return OkStatus();
+  }
+
+  Status Reset() override { return Seek(0); }
+
+ private:
+  RandomAccessFile* file_;  // Not owned.
+  int64_t pos_ = 0;         // Tracks where we are in the file.
+  bool owns_file_ = false;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_RANDOM_INPUTSTREAM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/record_reader.h

@@ -0,0 +1,180 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_RECORD_READER_H_
+#define TENSORFLOW_TSL_LIB_IO_RECORD_READER_H_
+
+#include "tsl/lib/io/inputstream_interface.h"
+#include "tsl/platform/errors.h"
+#include "tsl/platform/stringpiece.h"
+#if !defined(IS_SLIM_BUILD)
+#include "tsl/lib/io/snappy/snappy_compression_options.h"
+#include "tsl/lib/io/snappy/snappy_inputstream.h"
+#include "tsl/lib/io/zlib_compression_options.h"
+#include "tsl/lib/io/zlib_inputstream.h"
+#endif  // IS_SLIM_BUILD
+#include "tsl/platform/macros.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+class RandomAccessFile;
+
+namespace io {
+
+struct RecordReaderOptions {
+  enum CompressionType {
+    NONE = 0,
+    ZLIB_COMPRESSION = 1,
+    SNAPPY_COMPRESSION = 2
+  };
+  CompressionType compression_type = NONE;
+
+  // If buffer_size is non-zero, then all reads must be sequential, and no
+  // skipping around is permitted. (Note: this is the same behavior as reading
+  // compressed files.) Consider using SequentialRecordReader.
+  int64_t buffer_size = 0;
+
+  static RecordReaderOptions CreateRecordReaderOptions(
+      const string& compression_type);
+
+#if !defined(IS_SLIM_BUILD)
+  // Options specific to compression.
+  ZlibCompressionOptions zlib_options;
+  SnappyCompressionOptions snappy_options;
+#endif  // IS_SLIM_BUILD
+};
+
+// Low-level interface to read TFRecord files.
+//
+// If using compression or buffering, consider using SequentialRecordReader.
+//
+// Note: this class is not thread safe; external synchronization required.
+class RecordReader {
+ public:
+  // Format of a single record:
+  //  uint64    length
+  //  uint32    masked crc of length
+  //  byte      data[length]
+  //  uint32    masked crc of data
+  static constexpr size_t kHeaderSize = sizeof(uint64) + sizeof(uint32);
+  static constexpr size_t kFooterSize = sizeof(uint32);
+
+  // Statistics (sizes are in units of bytes)
+  struct Stats {
+    int64_t file_size = -1;
+    int64_t data_size = -1;
+    int64_t entries = -1;  // Number of values
+  };
+
+  // Metadata for the TFRecord file.
+  struct Metadata {
+    Stats stats;
+  };
+
+  // Create a reader that will return log records from "*file".
+  // "*file" must remain live while this Reader is in use.
+  explicit RecordReader(
+      tsl::RandomAccessFile* file,
+      const RecordReaderOptions& options = RecordReaderOptions());
+
+  virtual ~RecordReader() = default;
+
+  // Read the record at "*offset" into *record and update *offset to
+  // point to the offset of the next record.  Returns OK on success,
+  // OUT_OF_RANGE for end of file, or something else for an error.
+  Status ReadRecord(uint64* offset, tstring* record);
+
+  // Skip num_to_skip record starting at "*offset" and update *offset
+  // to point to the offset of the next num_to_skip + 1 record.
+  // Return OK on success, OUT_OF_RANGE for end of file, or something
+  // else for an error. "*num_skipped" records the number of records that
+  // are actually skipped. It should be equal to num_to_skip on success.
+  Status SkipRecords(uint64* offset, int num_to_skip, int* num_skipped);
+
+  // Return the metadata of the Record file.
+  //
+  // The current implementation scans the file to completion,
+  // skipping over the data regions, to extract the metadata once
+  // on the first call to GetStats().  An improved implementation
+  // would change RecordWriter to write the metadata into TFRecord
+  // so that GetMetadata() could be a const method.
+  //
+  // 'metadata' must not be nullptr.
+  Status GetMetadata(Metadata* md);
+
+ private:
+  Status ReadChecksummed(uint64 offset, size_t n, tstring* result);
+  Status PositionInputStream(uint64 offset);
+
+  RecordReaderOptions options_;
+  std::unique_ptr<InputStreamInterface> input_stream_;
+  bool last_read_failed_;
+
+  std::unique_ptr<Metadata> cached_metadata_;
+
+  RecordReader(const RecordReader&) = delete;
+  void operator=(const RecordReader&) = delete;
+};
+
+// High-level interface to read TFRecord files.
+//
+// Note: this class is not thread safe; external synchronization required.
+class SequentialRecordReader {
+ public:
+  // Create a reader that will return log records from "*file".
+  // "*file" must remain live while this Reader is in use.
+  explicit SequentialRecordReader(
+      tsl::RandomAccessFile* file,
+      const RecordReaderOptions& options = RecordReaderOptions());
+
+  virtual ~SequentialRecordReader() = default;
+
+  // Read the next record in the file into *record. Returns OK on success,
+  // OUT_OF_RANGE for end of file, or something else for an error.
+  Status ReadRecord(tstring* record) {
+    return underlying_.ReadRecord(&offset_, record);
+  }
+
+  // Skip the next num_to_skip record in the file. Return OK on success,
+  // OUT_OF_RANGE for end of file, or something else for an error.
+  // "*num_skipped" records the number of records that are actually skipped.
+  // It should be equal to num_to_skip on success.
+  Status SkipRecords(int num_to_skip, int* num_skipped) {
+    return underlying_.SkipRecords(&offset_, num_to_skip, num_skipped);
+  }
+
+  // Return the current offset in the file.
+  uint64 TellOffset() { return offset_; }
+
+  // Seek to this offset within the file and set this offset as the current
+  // offset. Trying to seek backward will throw error.
+  Status SeekOffset(uint64 offset) {
+    if (offset < offset_)
+      return errors::InvalidArgument(
+          "Trying to seek offset: ", offset,
+          " which is less than the current offset: ", offset_);
+    offset_ = offset;
+    return OkStatus();
+  }
+
+ private:
+  RecordReader underlying_;
+  uint64 offset_ = 0;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_RECORD_READER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/record_writer.h

@@ -0,0 +1,156 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_RECORD_WRITER_H_
+#define TENSORFLOW_TSL_LIB_IO_RECORD_WRITER_H_
+
+#include "tsl/lib/hash/crc32c.h"
+#include "tsl/platform/coding.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/stringpiece.h"
+#if !defined(IS_SLIM_BUILD)
+#include "tsl/lib/io/snappy/snappy_compression_options.h"
+#include "tsl/lib/io/snappy/snappy_outputbuffer.h"
+#include "tsl/lib/io/zlib_compression_options.h"
+#include "tsl/lib/io/zlib_outputbuffer.h"
+#endif  // IS_SLIM_BUILD
+#include "tsl/platform/cord.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+
+class WritableFile;
+
+namespace io {
+
+struct RecordWriterOptions {
+ public:
+  enum CompressionType {
+    NONE = 0,
+    ZLIB_COMPRESSION = 1,
+    SNAPPY_COMPRESSION = 2
+  };
+  CompressionType compression_type = NONE;
+
+  static RecordWriterOptions CreateRecordWriterOptions(
+      const string& compression_type);
+
+#if !defined(IS_SLIM_BUILD)
+  // Options specific to compression.
+  io::ZlibCompressionOptions zlib_options;
+  io::SnappyCompressionOptions snappy_options;
+#endif  // IS_SLIM_BUILD
+};
+
+class RecordWriter {
+ public:
+  // Format of a single record:
+  //  uint64    length
+  //  uint32    masked crc of length
+  //  byte      data[length]
+  //  uint32    masked crc of data
+  static constexpr size_t kHeaderSize = sizeof(uint64) + sizeof(uint32);
+  static constexpr size_t kFooterSize = sizeof(uint32);
+
+  // Create a writer that will append data to "*dest".
+  // "*dest" must be initially empty.
+  // "*dest" must remain live while this Writer is in use.
+  explicit RecordWriter(WritableFile* dest, const RecordWriterOptions& options =
+                                                RecordWriterOptions());
+
+  // Calls Close() and logs if an error occurs.
+  //
+  // TODO(jhseu): Require that callers explicitly call Close() and remove the
+  // implicit Close() call in the destructor.
+  ~RecordWriter();
+
+  Status WriteRecord(StringPiece data);
+
+#if defined(TF_CORD_SUPPORT)
+  Status WriteRecord(const absl::Cord& data);
+#endif
+
+  // Flushes any buffered data held by underlying containers of the
+  // RecordWriter to the WritableFile. Does *not* flush the
+  // WritableFile.
+  Status Flush();
+
+  // Writes all output to the file. Does *not* close the WritableFile.
+  //
+  // After calling Close(), any further calls to `WriteRecord()` or `Flush()`
+  // are invalid.
+  Status Close();
+
+  // Utility method to populate TFRecord headers.  Populates record-header in
+  // "header[0,kHeaderSize-1]".  The record-header is based on data[0, n-1].
+  inline static void PopulateHeader(char* header, const char* data, size_t n);
+
+#if defined(TF_CORD_SUPPORT)
+  inline static void PopulateHeader(char* header, const absl::Cord& data);
+#endif
+
+  // Utility method to populate TFRecord footers.  Populates record-footer in
+  // "footer[0,kFooterSize-1]".  The record-footer is based on data[0, n-1].
+  inline static void PopulateFooter(char* footer, const char* data, size_t n);
+
+#if defined(TF_CORD_SUPPORT)
+  inline static void PopulateFooter(char* footer, const absl::Cord& data);
+#endif
+
+ private:
+  WritableFile* dest_;
+  RecordWriterOptions options_;
+
+  inline static uint32 MaskedCrc(const char* data, size_t n) {
+    return crc32c::Mask(crc32c::Value(data, n));
+  }
+
+#if defined(TF_CORD_SUPPORT)
+  inline static uint32 MaskedCrc(const absl::Cord& data) {
+    return crc32c::Mask(crc32c::Value(data));
+  }
+#endif
+
+  RecordWriter(const RecordWriter&) = delete;
+  void operator=(const RecordWriter&) = delete;
+};
+
+void RecordWriter::PopulateHeader(char* header, const char* data, size_t n) {
+  core::EncodeFixed64(header + 0, n);
+  core::EncodeFixed32(header + sizeof(uint64),
+                      MaskedCrc(header, sizeof(uint64)));
+}
+
+void RecordWriter::PopulateFooter(char* footer, const char* data, size_t n) {
+  core::EncodeFixed32(footer, MaskedCrc(data, n));
+}
+
+#if defined(TF_CORD_SUPPORT)
+void RecordWriter::PopulateHeader(char* header, const absl::Cord& data) {
+  core::EncodeFixed64(header + 0, data.size());
+  core::EncodeFixed32(header + sizeof(uint64),
+                      MaskedCrc(header, sizeof(uint64)));
+}
+
+void RecordWriter::PopulateFooter(char* footer, const absl::Cord& data) {
+  core::EncodeFixed32(footer, MaskedCrc(data));
+}
+#endif
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_RECORD_WRITER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/snappy/snappy_compression_options.h

@@ -0,0 +1,36 @@
+/* Copyright 2020 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_COMPRESSION_OPTIONS_H_
+#define TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_COMPRESSION_OPTIONS_H_
+
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace io {
+
+struct SnappyCompressionOptions {
+  // Size of the buffer used for caching the data read from source file.
+  int64_t input_buffer_size = 256 << 10;
+
+  // Size of the sink buffer where the compressed/decompressed data produced by
+  // snappy is cached.
+  int64_t output_buffer_size = 256 << 10;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_COMPRESSION_OPTIONS_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/snappy/snappy_inputbuffer.h

@@ -0,0 +1,134 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_INPUTBUFFER_H_
+#define TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_INPUTBUFFER_H_
+
+#include <memory>
+#include <string>
+
+#include "tsl/lib/io/inputstream_interface.h"
+#include "tsl/platform/env.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/snappy.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace io {
+
+// An SnappyInputBuffer provides support for reading from a file compressed
+// using snappy (https://github.com/google/snappy).
+//
+// A given instance of an SnappyInputBuffer is NOT safe for concurrent use
+// by multiple threads
+class SnappyInputBuffer : public InputStreamInterface {
+ public:
+  // Create a SnappyInputBuffer for `file` with a buffer of size
+  // `input_buffer_bytes` bytes for reading contents from `file` and another
+  // buffer with size `output_buffer_bytes` for caching decompressed contents.
+  // Does *not* take ownership of "file".
+  SnappyInputBuffer(RandomAccessFile* file, size_t input_buffer_bytes,
+                    size_t output_buffer_bytes);
+
+  // Reads bytes_to_read bytes into *result, overwriting *result.
+  //
+  // Return Status codes:
+  // OK:
+  //   If successful.
+  // OUT_OF_RANGE:
+  //   If there are not enough bytes to read before the end of the file.
+  // DATA_LOSS:
+  //   If uncompression failed or if the file is corrupted.
+  // RESOURCE_EXHAUSTED:
+  //   If input_buffer_ is smaller in size than a compressed block.
+  // others:
+  //   If reading from file failed.
+  Status ReadNBytes(int64_t bytes_to_read, tstring* result) override;
+
+  int64_t Tell() const override;
+
+  Status Reset() override;
+
+ private:
+  // Reads data from `file_` and tries to fill up `input_buffer_` if enough
+  // unread data is left in `file_`.
+  //
+  // Looks up `next_in_` to check how much data in `input_buffer_`
+  // has already been read. The used data is removed and new data is added to
+  // after any unread data in `input_buffer_`.
+  // After this call `next_in` points to the start of `input_buffer_`
+  // and `avail_in_` stores the number of readable bytes in
+  // `input_buffer_`.
+  //
+  // Returns OutOfRange error if NO data could be read from file. Note that this
+  // won't return an OutOfRange if there wasn't sufficient data in file to
+  // completely fill up `input_buffer_`.
+  Status ReadFromFile();
+
+  // Reads the length of the next compressed block stored in the next 4 bytes at
+  // `next_in_`. Uncompresses the next compressed block and writes the output
+  // produced to the output_buffer_.
+  // Should be called only after the cached output has been consumed.
+  Status Inflate();
+
+  // Starts reading bytes at `next_out_` until either `bytes_to_read`
+  // bytes have been read or `next_out_` is reached.
+  // Returns the number of bytes read and advances the `next_out_`
+  // pointer to the next location to read from.
+  size_t ReadBytesFromCache(size_t bytes_to_read, char* result);
+
+  // Reads the length of the next *compressed* block and stores in `length`.
+  // The length is stored in 4 bytes in little endian notation.
+  Status ReadCompressedBlockLength(uint32* length);
+
+  RandomAccessFile* file_;         // Not owned
+  int64_t file_pos_ = 0;           // Next position to read from in `file_`
+  size_t input_buffer_capacity_;   // Size of `input_buffer_`.
+                                   // Must be at least as big as the size of
+                                   // the largest compressed block.
+  size_t output_buffer_capacity_;  // Size of `output_buffer_`
+
+  // Buffer for storing contents read from compressed file.
+  // TODO(srbs): Consider using circular buffers. That would greatly simplify
+  // the implementation.
+  std::unique_ptr<char[]> input_buffer_;
+
+  // Buffer for storing inflated contents of `file_`.
+  std::unique_ptr<char[]> output_buffer_;
+
+  // Next unread byte in `input_buffer_`.
+  char* next_in_;
+
+  // Next unread byte in `output_buffer_`
+  char* next_out_;
+
+  // Number of unread bytes available at `next_in_` in `input_buffer_`.
+  size_t avail_in_ = 0;
+
+  // Number of unread bytes available at `next_out_` in `output_buffer_`.
+  size_t avail_out_ = 0;
+
+  // Number of *uncompressed* bytes that have been read from this stream.
+  int64_t bytes_read_;
+
+  SnappyInputBuffer(const SnappyInputBuffer&) = delete;
+  void operator=(const SnappyInputBuffer&) = delete;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_INPUTBUFFER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/snappy/snappy_inputstream.h

@@ -0,0 +1,92 @@
+/* Copyright 2020 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_INPUTSTREAM_H_
+#define TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_INPUTSTREAM_H_
+
+#include <memory>
+
+#include "tsl/lib/io/inputstream_interface.h"
+
+namespace tsl {
+namespace io {
+
+class SnappyInputStream : public InputStreamInterface {
+ public:
+  // Creates a SnappyInputStream for `input_stream`.
+  //
+  // Takes ownership  of `input_stream` iff `owns_input_stream` is true.
+  SnappyInputStream(InputStreamInterface* input_stream,
+                    size_t output_buffer_bytes, bool owns_input_stream);
+
+  // Equivalent to the previous constructor with owns_input_stream = false.
+  explicit SnappyInputStream(InputStreamInterface* input_stream,
+                             size_t output_buffer_bytes);
+
+  ~SnappyInputStream() override;
+
+  // Reads bytes_to_read bytes into *result, overwriting *result.
+  //
+  // Return Status codes:
+  // OK:           If successful.
+  // OUT_OF_RANGE: If there are not enough bytes to read before
+  //               the end of the stream.
+  // ABORTED:      If inflate() fails, we return the error code with the
+  //               error message in `z_stream_->msg`.
+  // others:       If reading from stream failed.
+  Status ReadNBytes(int64_t bytes_to_read, tstring* result) override;
+
+#if defined(TF_CORD_SUPPORT)
+  Status ReadNBytes(int64_t bytes_to_read, absl::Cord* result) override;
+#endif
+
+  int64_t Tell() const override;
+
+  Status Reset() override;
+
+ private:
+  // Decompress the next chunk of data and place the data into the cache.
+  Status Inflate();
+
+  // Attempt to read `bytes_to_read` from the decompressed data cache. Returns
+  // the actual number of bytes read.
+  size_t ReadBytesFromCache(size_t bytes_to_read, char* result);
+
+  InputStreamInterface* input_stream_;
+  const size_t output_buffer_bytes_;
+  const bool owns_input_stream_;
+
+  // Specifies the number of decompressed bytes currently read.
+  int64_t bytes_read_;
+
+  // output_buffer_ contains decompressed data not yet read by the client.
+  std::unique_ptr<char[]> output_buffer_;
+
+  // next_out_ points to the position in the `output_buffer_` that contains the
+  // next unread byte.
+  char* next_out_;
+
+  // avail_out_ specifies the number of bytes left in the output_buffers_ that
+  // is not yet read.
+  size_t avail_out_;
+
+  SnappyInputStream(const SnappyInputStream&) = delete;
+  void operator=(const SnappyInputStream&) = delete;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_INPUTSTREAM_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/snappy/snappy_outputbuffer.h

@@ -0,0 +1,158 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_OUTPUTBUFFER_H_
+#define TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_OUTPUTBUFFER_H_
+
+#include <memory>
+#include <string>
+
+#include "tsl/platform/env.h"
+#include "tsl/platform/macros.h"
+#include "tsl/platform/platform.h"
+#include "tsl/platform/snappy.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/types.h"
+
+namespace tsl {
+namespace io {
+
+// Compresses input data using Snappy (https://github.com/google/snappy) and
+// writes to `file`.
+//
+// The input data is cached in a buffer of size `input_buffer_bytes`. When the
+// buffer does not have enough available space to fit new data (in the call to
+// `Write`), the contents of the buffer are compressed and sent to the output
+// buffer.
+//
+// The compressed output is buffered in a buffer of size `output_buffer_bytes`
+// which gets flushed to file when full.
+//
+// Output file format:
+// The output file consists of a sequence of compressed blocks. Each block
+// starts with a 4 byte header which stores the length (in bytes) of the
+// _compressed_ block _excluding_ this header. The compressed
+// block (excluding the 4 byte header) is a valid snappy block and can directly
+// be uncompressed using Snappy_Uncompress.
+class SnappyOutputBuffer : public WritableFile {
+ public:
+  // Create an SnappyOutputBuffer for `file` with two buffers that cache the
+  // 1. input data to be deflated
+  // 2. the deflated output
+  // with sizes `input_buffer_bytes` and `output_buffer_bytes` respectively.
+  // Does not take ownership of `file`.
+  SnappyOutputBuffer(WritableFile* file, int32_t input_buffer_bytes,
+                     int32_t output_buffer_bytes);
+
+  // Per convention, the dtor does not call Flush() or Close(). We expect the
+  // caller to call those manually when done.
+  ~SnappyOutputBuffer() override;
+
+  // Adds `data` to the compression pipeline.
+  //
+  // The input data is buffered internally and will be written to disk at a
+  // later time. To immediately write contents to file call `Flush()`.
+  Status Append(StringPiece data) override;
+
+#if defined(TF_CORD_SUPPORT)
+  Status Append(const absl::Cord& cord) override;
+#endif
+
+  // Compresses any buffered input and writes all output to file. This must be
+  // called before the destructor to avoid any data loss.
+  //
+  // Contrary to `Flush()` this informs snappy that it should not expect any
+  // further input.
+  //
+  // After calling this, any further calls to `Write()`, `Flush()` or `Close()`
+  // will fail.
+  Status Close() override;
+
+  // Returns the name of the underlying file.
+  Status Name(StringPiece* result) const override;
+
+  // Deflates any cached input, writes all output to file and syncs it.
+  Status Sync() override;
+
+  // Returns the write position in the underlying file. The position does not
+  // reflect buffered, un-flushed data.
+  Status Tell(int64_t* position) override;
+
+  // Adds `data` to the compression pipeline.
+  //
+  // The input data is buffered in `input_buffer_` and is compressed in bulk
+  // when the buffer gets full. The compressed output may not be immediately
+  // written to file but rather buffered in `output_buffer_` and gets written
+  // to file when the buffer is full.
+  //
+  // To immediately write contents to file call `Flush()`.
+  Status Write(StringPiece data);
+
+  // Compresses any cached input and writes all output to file. This must be
+  // called before the destructor to avoid any data loss.
+  Status Flush() override;
+
+ private:
+  // Appends `data` to `input_buffer_`.
+  // Throws if `data.size()` > AvailableInputSpace().
+  void AddToInputBuffer(StringPiece data);
+
+  // Appends `data` to `output_buffer_`. Flushes buffer contents to file when
+  // buffer gets full.
+  Status AddToOutputBuffer(const char* data, size_t length);
+
+  // Returns the total space available in `input_buffer_`.
+  int32 AvailableInputSpace() const;
+
+  // Deflate contents in input_buffer_ and store results in output_buffer_.
+  // The contents of output stream are written to file if more space is needed.
+  //
+  // Note: This method does not flush contents to file.
+  // Returns non-ok status if writing contents to file fails.
+  Status DeflateBuffered();
+
+  // Appends contents of `output_buffer_` to `file_`.
+  // Returns non-OK status if writing to file fails.
+  Status FlushOutputBufferToFile();
+
+  // Compresses `avail_in_` bytes at `next_in_` location in `input_buffer_` and
+  // writes the results to output using `AddToOutputBuffer`.
+  // Returns non-OK status if writing to file failed.
+  Status Deflate();
+
+  WritableFile* file_;  // Not owned
+
+  // Buffer for storing contents read from input `file_`.
+  // TODO(srbs): Consider using circular buffers. That would greatly simplify
+  // the implementation.
+  std::unique_ptr<char[]> input_buffer_;
+  size_t input_buffer_capacity_;
+  char* next_in_;
+  size_t avail_in_ = 0;
+
+  // Buffer for storing deflated contents of `file_`.
+  std::unique_ptr<char[]> output_buffer_;
+  size_t output_buffer_capacity_;
+  char* next_out_;
+  size_t avail_out_;
+
+  SnappyOutputBuffer(const SnappyOutputBuffer&) = delete;
+  void operator=(const SnappyOutputBuffer&) = delete;
+};
+
+}  // namespace io
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_SNAPPY_SNAPPY_OUTPUTBUFFER_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/table.h

@@ -0,0 +1,86 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_TSL_LIB_IO_TABLE_H_
+#define TENSORFLOW_TSL_LIB_IO_TABLE_H_
+
+#include <stdint.h>
+
+#include "tsl/lib/io/iterator.h"
+
+namespace tsl {
+
+class RandomAccessFile;
+
+namespace table {
+
+struct Options;
+
+// A Table is a sorted map from strings to strings.  Tables are
+// immutable and persistent.  A Table may be safely accessed from
+// multiple threads without external synchronization.
+class Table {
+ public:
+  // Attempt to open the table that is stored in bytes [0..file_size)
+  // of "file", and read the metadata entries necessary to allow
+  // retrieving data from the table.
+  //
+  // If successful, returns ok and sets "*table" to the newly opened
+  // table.  The client should delete "*table" when no longer needed.
+  // If there was an error while initializing the table, sets "*table"
+  // to NULL and returns a non-ok status.  Does not take ownership of
+  // "*file", but the client must ensure that "file" remains live
+  // for the duration of the returned table's lifetime.
+  static Status Open(const Options& options, tsl::RandomAccessFile* file,
+                     uint64 file_size, Table** table);
+
+  ~Table();
+
+  // Returns a new iterator over the table contents.
+  // The result of NewIterator() is initially invalid (caller must
+  // call one of the Seek methods on the iterator before using it).
+  Iterator* NewIterator() const;
+
+  // Given a key, return an approximate byte offset in the file where
+  // the data for that key begins (or would begin if the key were
+  // present in the file).  The returned value is in terms of file
+  // bytes, and so includes effects like compression of the underlying data.
+  // E.g., the approximate offset of the last key in the table will
+  // be close to the file length.
+  uint64 ApproximateOffsetOf(const StringPiece& key) const;
+
+ private:
+  struct Rep;
+  Rep* rep_;
+
+  explicit Table(Rep* rep) { rep_ = rep; }
+  static Iterator* BlockReader(void*, const StringPiece&);
+
+  // Calls (*handle_result)(arg, ...) with the entry found after a call
+  // to Seek(key).  May not make such a call if filter policy says
+  // that key is not present.
+  Status InternalGet(const StringPiece& key, void* arg,
+                     void (*handle_result)(void* arg, const StringPiece& k,
+                                           const StringPiece& v));
+
+  // No copying allowed
+  Table(const Table&);
+  void operator=(const Table&);
+};
+
+}  // namespace table
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_TABLE_H_

videochat2/lib/python3.10/site-packages/tensorflow/include/tsl/lib/io/table_builder.h

@@ -0,0 +1,101 @@
+/* Copyright 2015 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.
+==============================================================================*/
+
+// TableBuilder provides the interface used to build a Table
+// (an immutable and sorted map from keys to values).
+//
+// Multiple threads can invoke const methods on a TableBuilder without
+// external synchronization, but if any of the threads may call a
+// non-const method, all threads accessing the same TableBuilder must use
+// external synchronization.
+
+#ifndef TENSORFLOW_TSL_LIB_IO_TABLE_BUILDER_H_
+#define TENSORFLOW_TSL_LIB_IO_TABLE_BUILDER_H_
+
+#include <stdint.h>
+
+#include "tsl/lib/io/table_options.h"
+#include "tsl/platform/status.h"
+#include "tsl/platform/stringpiece.h"
+
+namespace tsl {
+class WritableFile;
+namespace table {
+
+class BlockBuilder;
+class BlockHandle;
+
+class TableBuilder {
+ public:
+  // Create a builder that will store the contents of the table it is
+  // building in *file.  Does not close the file.  It is up to the
+  // caller to close the file after calling Finish().
+  TableBuilder(const Options& options, tsl::WritableFile* file);
+
+  // REQUIRES: Either Finish() or Abandon() has been called.
+  ~TableBuilder();
+
+  // Add key,value to the table being constructed.
+  // REQUIRES: key is after any previously added key in lexicographic order.
+  // REQUIRES: Finish(), Abandon() have not been called
+  void Add(const StringPiece& key, const StringPiece& value);
+
+  // Advanced operation: writes any buffered key/value pairs to file.
+  // Can be used to ensure that two adjacent entries never live in
+  // the same data block.  Most clients should not need to use this method.
+  // Does not flush the file itself.
+  // REQUIRES: Finish(), Abandon() have not been called
+  void Flush();
+
+  // Return non-ok iff some error has been detected.
+  Status status() const;
+
+  // Finish building the table.  Stops using the file passed to the
+  // constructor after this function returns.
+  // REQUIRES: Finish(), Abandon() have not been called
+  Status Finish();
+
+  // Indicate that the contents of this builder should be abandoned.  Stops
+  // using the file passed to the constructor after this function returns.
+  // If the caller is not going to call Finish(), it must call Abandon()
+  // before destroying this builder.
+  // REQUIRES: Finish(), Abandon() have not been called
+  void Abandon();
+
+  // Number of calls to Add() so far.
+  uint64 NumEntries() const;
+
+  // Size of the file generated so far.  If invoked after a successful
+  // Finish() call, returns the size of the final generated file.
+  uint64 FileSize() const;
+
+ private:
+  bool ok() const { return status().ok(); }
+  void WriteBlock(BlockBuilder* block, BlockHandle* handle);
+  void WriteRawBlock(const StringPiece& data, CompressionType,
+                     BlockHandle* handle);
+
+  struct Rep;
+  Rep* rep_;
+
+  // No copying allowed
+  TableBuilder(const TableBuilder&);
+  void operator=(const TableBuilder&);
+};
+
+}  // namespace table
+}  // namespace tsl
+
+#endif  // TENSORFLOW_TSL_LIB_IO_TABLE_BUILDER_H_