Publish 11 evaluated Astra histories with reproducible checkpoint artifacts (part 40)

.gitattributes

@@ -947,3 +947,39 @@ shared/package-files/cf/cfbd026d00067a99aa9f14d1d5aa48076a97ad39e7d32c49c8964a10
 shared/package-files/cf/cfccd871b530fa1b23e6ed6ec1f43940cdb564930e6086a35d116e6636072077/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/d0/d060a9597056170ec121b704840e838df98bece671673e490c84bc82c788fa83/blob filter=lfs diff=lfs merge=lfs -text
 shared/package-files/d0/d08783f85bb4a16dcd73eb9317000b97ce811a98e0c43d44566912b21427bf82/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d0/d0ffb4973b6651de10e60155e16d7f39a3ead8da0aa3b1a5be6fb181122a8f7d/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d1/d1077656f59bb84a73d5c477a4adafdd8761d037a58e4b5b9fed8f8dbb2275f9/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d1/d19d9d3c170a074e2c4ff56b606761e5d6686077a9460416e4691a0368d6b6b6/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d1/d1a0ed4d9a1da76ba5dab410441bb83f6415a841acdc130d20c6504dfaf11cde/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d1/d1efe233bd4d377b622ad09f65035bf89e2dfcbec5a0b0444c2e235c5773acd7/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d2/d2acdedbf3527da2d985ce1c3a9929efaecf0f1ba63056e2b6080591247e2c58/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d2/d2bc0b8127ab14cf1df3ae8fe4242829830ef54cc00ceafd720e68ef7e67f495/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d2/d2da887bd5aba8f90b9726beefe1a4dd174e541ef39952f69b3492df0591a9ba/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d30758e332c4303643f19db8061f1e79956a86a625883d04fae87cc269a1d17e/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d30adf6a4e7bac0145680e67ceed3e9d2ff4a2ca579a147cf8815a6949a2c42e/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d30e994b09d9f30f7efeb6dc81fa05ab4a7be32b4e78c2b48fc3b6228197bfb1/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d3193fe31df6de065d5f9c45edccb24076c9635c52711920feabfc03cf82c8e3/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d32dfd0be03bd30fe392602e724b9d6fa0586c430b9be830373b644480005dd9/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d35a02302739bc85f331fe098b3720b6890cbac159fb118d7497cd66ce77baa0/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d3606ac2d52a59ae272e5b9aac1fd098a54424a51a45135fa3b2104e64a49386/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d384478bd58d755f22fea782c703bff940e3bbd360709299ddfd1440ce6a725b/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d3c3f7c9115cc2e890683e9783dd74ed139b39a6ab8a5b48793453943680e9f9/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d3e2267ac18118806a4772d389c3fca4d5a01f40a0044dbc5a3951ca4dfb9260/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d3/d3ea52e7b6e968de0d884df1288193596fa95b803db4f92a18279a7398004475/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d4/d416d5e4b518c98b57b02f02b1a159659ba6395fcabd527f076fa6fdb7517ddb/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d4/d45be6bf592c88a6cd24910bb2ea3f254bbdac51e9edcfd1a3e3a43370d8b3c5/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d4/d493f50a33e82a4420494c54d1fca1539d177bdc27ab190bc5fe6e92f62fb637/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d4/d4d827a9d5d6453982f115f7e7bb448f2b23d64b5b89de61a64e838c2f936200/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d4/d4e8951ded34a4600e91fe80d4ac7854276eedd16f51bb353794b7d2c2831f70/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d5/d52293a81c168347002c88a81f2469cb8be72e7a527699946b68b4614b857dfe/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d6/d67eea63a4087be25684a220992163dd59b69edae920409aed2e90f2e98c0d63/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d6/d6c59efae8add1fbaa406a1007eca03df58ac39e657b175d7cb82682ce37369f/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d6/d6f9e4af876bfad3c56c075e1b07237354d5e06c9a55e9c266b222dfb2959080/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d7/d728ffa4ec2c862fea5d967d31cf087f19277c20070929c27a17eeedff1baef2/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d7/d73ecbbb51654522342ba0470a6263a9684e617c2b8374565fe3a79593f4b231/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d7/d7a4ad8c10ee00bc2de44643e236cfec19b8d50cb395752edfc7dca8ffd6cf57/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d7/d7d121e5f899fb71a1439aa3f7f51121e0ea64f30a736697072363fe38b30474/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d8/d8202427dad506a3249765966fe80d020ca7813e8fa3d110a428a76cca98aee7/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d8/d83125fd8622c1a69e29ca0aa80740c045420a4020db860f382926ff457b1331/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d8/d8649d1526f08fd0c1c2d6de0e7ef607e07f103f8f8670a83ade7c5d2d6a7a1a/blob filter=lfs diff=lfs merge=lfs -text
+shared/package-files/d8/d87ed7aee3a3b78f1c2478f568a3a79e4010a110fccc3c9bad0a1ca414c917f2/blob filter=lfs diff=lfs merge=lfs -text

shared/package-files/d0/d0ed059a6121cde784526964992365b87b995618654ce2041ead5873e8572c56/blob

@@ -0,0 +1,471 @@
+ERROR_FIRST: int
+HASHCHK: int
+NISAMCHK: int
+NO: int
+YES: int
+CANT_CREATE_FILE: int
+CANT_CREATE_TABLE: int
+CANT_CREATE_DB: int
+DB_CREATE_EXISTS: int
+DB_DROP_EXISTS: int
+DB_DROP_DELETE: int
+DB_DROP_RMDIR: int
+CANT_DELETE_FILE: int
+CANT_FIND_SYSTEM_REC: int
+CANT_GET_STAT: int
+CANT_GET_WD: int
+CANT_LOCK: int
+CANT_OPEN_FILE: int
+FILE_NOT_FOUND: int
+CANT_READ_DIR: int
+CANT_SET_WD: int
+CHECKREAD: int
+DISK_FULL: int
+DUP_KEY: int
+ERROR_ON_CLOSE: int
+ERROR_ON_READ: int
+ERROR_ON_RENAME: int
+ERROR_ON_WRITE: int
+FILE_USED: int
+FILSORT_ABORT: int
+FORM_NOT_FOUND: int
+GET_ERRNO: int
+ILLEGAL_HA: int
+KEY_NOT_FOUND: int
+NOT_FORM_FILE: int
+NOT_KEYFILE: int
+OLD_KEYFILE: int
+OPEN_AS_READONLY: int
+OUTOFMEMORY: int
+OUT_OF_SORTMEMORY: int
+UNEXPECTED_EOF: int
+CON_COUNT_ERROR: int
+OUT_OF_RESOURCES: int
+BAD_HOST_ERROR: int
+HANDSHAKE_ERROR: int
+DBACCESS_DENIED_ERROR: int
+ACCESS_DENIED_ERROR: int
+NO_DB_ERROR: int
+UNKNOWN_COM_ERROR: int
+BAD_NULL_ERROR: int
+BAD_DB_ERROR: int
+TABLE_EXISTS_ERROR: int
+BAD_TABLE_ERROR: int
+NON_UNIQ_ERROR: int
+SERVER_SHUTDOWN: int
+BAD_FIELD_ERROR: int
+WRONG_FIELD_WITH_GROUP: int
+WRONG_GROUP_FIELD: int
+WRONG_SUM_SELECT: int
+WRONG_VALUE_COUNT: int
+TOO_LONG_IDENT: int
+DUP_FIELDNAME: int
+DUP_KEYNAME: int
+DUP_ENTRY: int
+WRONG_FIELD_SPEC: int
+PARSE_ERROR: int
+EMPTY_QUERY: int
+NONUNIQ_TABLE: int
+INVALID_DEFAULT: int
+MULTIPLE_PRI_KEY: int
+TOO_MANY_KEYS: int
+TOO_MANY_KEY_PARTS: int
+TOO_LONG_KEY: int
+KEY_COLUMN_DOES_NOT_EXITS: int
+BLOB_USED_AS_KEY: int
+TOO_BIG_FIELDLENGTH: int
+WRONG_AUTO_KEY: int
+READY: int
+NORMAL_SHUTDOWN: int
+GOT_SIGNAL: int
+SHUTDOWN_COMPLETE: int
+FORCING_CLOSE: int
+IPSOCK_ERROR: int
+NO_SUCH_INDEX: int
+WRONG_FIELD_TERMINATORS: int
+BLOBS_AND_NO_TERMINATED: int
+TEXTFILE_NOT_READABLE: int
+FILE_EXISTS_ERROR: int
+LOAD_INFO: int
+ALTER_INFO: int
+WRONG_SUB_KEY: int
+CANT_REMOVE_ALL_FIELDS: int
+CANT_DROP_FIELD_OR_KEY: int
+INSERT_INFO: int
+UPDATE_TABLE_USED: int
+NO_SUCH_THREAD: int
+KILL_DENIED_ERROR: int
+NO_TABLES_USED: int
+TOO_BIG_SET: int
+NO_UNIQUE_LOGFILE: int
+TABLE_NOT_LOCKED_FOR_WRITE: int
+TABLE_NOT_LOCKED: int
+BLOB_CANT_HAVE_DEFAULT: int
+WRONG_DB_NAME: int
+WRONG_TABLE_NAME: int
+TOO_BIG_SELECT: int
+UNKNOWN_ERROR: int
+UNKNOWN_PROCEDURE: int
+WRONG_PARAMCOUNT_TO_PROCEDURE: int
+WRONG_PARAMETERS_TO_PROCEDURE: int
+UNKNOWN_TABLE: int
+FIELD_SPECIFIED_TWICE: int
+INVALID_GROUP_FUNC_USE: int
+UNSUPPORTED_EXTENSION: int
+TABLE_MUST_HAVE_COLUMNS: int
+RECORD_FILE_FULL: int
+UNKNOWN_CHARACTER_SET: int
+TOO_MANY_TABLES: int
+TOO_MANY_FIELDS: int
+TOO_BIG_ROWSIZE: int
+STACK_OVERRUN: int
+WRONG_OUTER_JOIN: int
+NULL_COLUMN_IN_INDEX: int
+CANT_FIND_UDF: int
+CANT_INITIALIZE_UDF: int
+UDF_NO_PATHS: int
+UDF_EXISTS: int
+CANT_OPEN_LIBRARY: int
+CANT_FIND_DL_ENTRY: int
+FUNCTION_NOT_DEFINED: int
+HOST_IS_BLOCKED: int
+HOST_NOT_PRIVILEGED: int
+PASSWORD_ANONYMOUS_USER: int
+PASSWORD_NOT_ALLOWED: int
+PASSWORD_NO_MATCH: int
+UPDATE_INFO: int
+CANT_CREATE_THREAD: int
+WRONG_VALUE_COUNT_ON_ROW: int
+CANT_REOPEN_TABLE: int
+INVALID_USE_OF_NULL: int
+REGEXP_ERROR: int
+MIX_OF_GROUP_FUNC_AND_FIELDS: int
+NONEXISTING_GRANT: int
+TABLEACCESS_DENIED_ERROR: int
+COLUMNACCESS_DENIED_ERROR: int
+ILLEGAL_GRANT_FOR_TABLE: int
+GRANT_WRONG_HOST_OR_USER: int
+NO_SUCH_TABLE: int
+NONEXISTING_TABLE_GRANT: int
+NOT_ALLOWED_COMMAND: int
+SYNTAX_ERROR: int
+DELAYED_CANT_CHANGE_LOCK: int
+TOO_MANY_DELAYED_THREADS: int
+ABORTING_CONNECTION: int
+NET_PACKET_TOO_LARGE: int
+NET_READ_ERROR_FROM_PIPE: int
+NET_FCNTL_ERROR: int
+NET_PACKETS_OUT_OF_ORDER: int
+NET_UNCOMPRESS_ERROR: int
+NET_READ_ERROR: int
+NET_READ_INTERRUPTED: int
+NET_ERROR_ON_WRITE: int
+NET_WRITE_INTERRUPTED: int
+TOO_LONG_STRING: int
+TABLE_CANT_HANDLE_BLOB: int
+TABLE_CANT_HANDLE_AUTO_INCREMENT: int
+DELAYED_INSERT_TABLE_LOCKED: int
+WRONG_COLUMN_NAME: int
+WRONG_KEY_COLUMN: int
+WRONG_MRG_TABLE: int
+DUP_UNIQUE: int
+BLOB_KEY_WITHOUT_LENGTH: int
+PRIMARY_CANT_HAVE_NULL: int
+TOO_MANY_ROWS: int
+REQUIRES_PRIMARY_KEY: int
+NO_RAID_COMPILED: int
+UPDATE_WITHOUT_KEY_IN_SAFE_MODE: int
+KEY_DOES_NOT_EXITS: int
+CHECK_NO_SUCH_TABLE: int
+CHECK_NOT_IMPLEMENTED: int
+CANT_DO_THIS_DURING_AN_TRANSACTION: int
+ERROR_DURING_COMMIT: int
+ERROR_DURING_ROLLBACK: int
+ERROR_DURING_FLUSH_LOGS: int
+ERROR_DURING_CHECKPOINT: int
+NEW_ABORTING_CONNECTION: int
+DUMP_NOT_IMPLEMENTED: int
+FLUSH_MASTER_BINLOG_CLOSED: int
+INDEX_REBUILD: int
+MASTER: int
+MASTER_NET_READ: int
+MASTER_NET_WRITE: int
+FT_MATCHING_KEY_NOT_FOUND: int
+LOCK_OR_ACTIVE_TRANSACTION: int
+UNKNOWN_SYSTEM_VARIABLE: int
+CRASHED_ON_USAGE: int
+CRASHED_ON_REPAIR: int
+WARNING_NOT_COMPLETE_ROLLBACK: int
+TRANS_CACHE_FULL: int
+SLAVE_MUST_STOP: int
+SLAVE_NOT_RUNNING: int
+BAD_SLAVE: int
+MASTER_INFO: int
+SLAVE_THREAD: int
+TOO_MANY_USER_CONNECTIONS: int
+SET_CONSTANTS_ONLY: int
+LOCK_WAIT_TIMEOUT: int
+LOCK_TABLE_FULL: int
+READ_ONLY_TRANSACTION: int
+DROP_DB_WITH_READ_LOCK: int
+CREATE_DB_WITH_READ_LOCK: int
+WRONG_ARGUMENTS: int
+NO_PERMISSION_TO_CREATE_USER: int
+UNION_TABLES_IN_DIFFERENT_DIR: int
+LOCK_DEADLOCK: int
+TABLE_CANT_HANDLE_FT: int
+CANNOT_ADD_FOREIGN: int
+NO_REFERENCED_ROW: int
+ROW_IS_REFERENCED: int
+CONNECT_TO_MASTER: int
+QUERY_ON_MASTER: int
+ERROR_WHEN_EXECUTING_COMMAND: int
+WRONG_USAGE: int
+WRONG_NUMBER_OF_COLUMNS_IN_SELECT: int
+CANT_UPDATE_WITH_READLOCK: int
+MIXING_NOT_ALLOWED: int
+DUP_ARGUMENT: int
+USER_LIMIT_REACHED: int
+SPECIFIC_ACCESS_DENIED_ERROR: int
+LOCAL_VARIABLE: int
+GLOBAL_VARIABLE: int
+NO_DEFAULT: int
+WRONG_VALUE_FOR_VAR: int
+WRONG_TYPE_FOR_VAR: int
+VAR_CANT_BE_READ: int
+CANT_USE_OPTION_HERE: int
+NOT_SUPPORTED_YET: int
+MASTER_FATAL_ERROR_READING_BINLOG: int
+SLAVE_IGNORED_TABLE: int
+INCORRECT_GLOBAL_LOCAL_VAR: int
+WRONG_FK_DEF: int
+KEY_REF_DO_NOT_MATCH_TABLE_REF: int
+OPERAND_COLUMNS: int
+SUBQUERY_NO_1_ROW: int
+UNKNOWN_STMT_HANDLER: int
+CORRUPT_HELP_DB: int
+CYCLIC_REFERENCE: int
+AUTO_CONVERT: int
+ILLEGAL_REFERENCE: int
+DERIVED_MUST_HAVE_ALIAS: int
+SELECT_REDUCED: int
+TABLENAME_NOT_ALLOWED_HERE: int
+NOT_SUPPORTED_AUTH_MODE: int
+SPATIAL_CANT_HAVE_NULL: int
+COLLATION_CHARSET_MISMATCH: int
+SLAVE_WAS_RUNNING: int
+SLAVE_WAS_NOT_RUNNING: int
+TOO_BIG_FOR_UNCOMPRESS: int
+ZLIB_Z_MEM_ERROR: int
+ZLIB_Z_BUF_ERROR: int
+ZLIB_Z_DATA_ERROR: int
+CUT_VALUE_GROUP_CONCAT: int
+WARN_TOO_FEW_RECORDS: int
+WARN_TOO_MANY_RECORDS: int
+WARN_NULL_TO_NOTNULL: int
+WARN_DATA_OUT_OF_RANGE: int
+WARN_DATA_TRUNCATED: int
+WARN_USING_OTHER_HANDLER: int
+CANT_AGGREGATE_2COLLATIONS: int
+DROP_USER: int
+REVOKE_GRANTS: int
+CANT_AGGREGATE_3COLLATIONS: int
+CANT_AGGREGATE_NCOLLATIONS: int
+VARIABLE_IS_NOT_STRUCT: int
+UNKNOWN_COLLATION: int
+SLAVE_IGNORED_SSL_PARAMS: int
+SERVER_IS_IN_SECURE_AUTH_MODE: int
+WARN_FIELD_RESOLVED: int
+BAD_SLAVE_UNTIL_COND: int
+MISSING_SKIP_SLAVE: int
+UNTIL_COND_IGNORED: int
+WRONG_NAME_FOR_INDEX: int
+WRONG_NAME_FOR_CATALOG: int
+WARN_QC_RESIZE: int
+BAD_FT_COLUMN: int
+UNKNOWN_KEY_CACHE: int
+WARN_HOSTNAME_WONT_WORK: int
+UNKNOWN_STORAGE_ENGINE: int
+WARN_DEPRECATED_SYNTAX: int
+NON_UPDATABLE_TABLE: int
+FEATURE_DISABLED: int
+OPTION_PREVENTS_STATEMENT: int
+DUPLICATED_VALUE_IN_TYPE: int
+TRUNCATED_WRONG_VALUE: int
+TOO_MUCH_AUTO_TIMESTAMP_COLS: int
+INVALID_ON_UPDATE: int
+UNSUPPORTED_PS: int
+GET_ERRMSG: int
+GET_TEMPORARY_ERRMSG: int
+UNKNOWN_TIME_ZONE: int
+WARN_INVALID_TIMESTAMP: int
+INVALID_CHARACTER_STRING: int
+WARN_ALLOWED_PACKET_OVERFLOWED: int
+CONFLICTING_DECLARATIONS: int
+SP_NO_RECURSIVE_CREATE: int
+SP_ALREADY_EXISTS: int
+SP_DOES_NOT_EXIST: int
+SP_DROP_FAILED: int
+SP_STORE_FAILED: int
+SP_LILABEL_MISMATCH: int
+SP_LABEL_REDEFINE: int
+SP_LABEL_MISMATCH: int
+SP_UNINIT_VAR: int
+SP_BADSELECT: int
+SP_BADRETURN: int
+SP_BADSTATEMENT: int
+UPDATE_LOG_DEPRECATED_IGNORED: int
+UPDATE_LOG_DEPRECATED_TRANSLATED: int
+QUERY_INTERRUPTED: int
+SP_WRONG_NO_OF_ARGS: int
+SP_COND_MISMATCH: int
+SP_NORETURN: int
+SP_NORETURNEND: int
+SP_BAD_CURSOR_QUERY: int
+SP_BAD_CURSOR_SELECT: int
+SP_CURSOR_MISMATCH: int
+SP_CURSOR_ALREADY_OPEN: int
+SP_CURSOR_NOT_OPEN: int
+SP_UNDECLARED_VAR: int
+SP_WRONG_NO_OF_FETCH_ARGS: int
+SP_FETCH_NO_DATA: int
+SP_DUP_PARAM: int
+SP_DUP_VAR: int
+SP_DUP_COND: int
+SP_DUP_CURS: int
+SP_CANT_ALTER: int
+SP_SUBSELECT_NYI: int
+STMT_NOT_ALLOWED_IN_SF_OR_TRG: int
+SP_VARCOND_AFTER_CURSHNDLR: int
+SP_CURSOR_AFTER_HANDLER: int
+SP_CASE_NOT_FOUND: int
+FPARSER_TOO_BIG_FILE: int
+FPARSER_BAD_HEADER: int
+FPARSER_EOF_IN_COMMENT: int
+FPARSER_ERROR_IN_PARAMETER: int
+FPARSER_EOF_IN_UNKNOWN_PARAMETER: int
+VIEW_NO_EXPLAIN: int
+FRM_UNKNOWN_TYPE: int
+WRONG_OBJECT: int
+NONUPDATEABLE_COLUMN: int
+VIEW_SELECT_DERIVED: int
+VIEW_SELECT_CLAUSE: int
+VIEW_SELECT_VARIABLE: int
+VIEW_SELECT_TMPTABLE: int
+VIEW_WRONG_LIST: int
+WARN_VIEW_MERGE: int
+WARN_VIEW_WITHOUT_KEY: int
+VIEW_INVALID: int
+SP_NO_DROP_SP: int
+SP_GOTO_IN_HNDLR: int
+TRG_ALREADY_EXISTS: int
+TRG_DOES_NOT_EXIST: int
+TRG_ON_VIEW_OR_TEMP_TABLE: int
+TRG_CANT_CHANGE_ROW: int
+TRG_NO_SUCH_ROW_IN_TRG: int
+NO_DEFAULT_FOR_FIELD: int
+DIVISION_BY_ZERO: int
+TRUNCATED_WRONG_VALUE_FOR_FIELD: int
+ILLEGAL_VALUE_FOR_TYPE: int
+VIEW_NONUPD_CHECK: int
+VIEW_CHECK_FAILED: int
+PROCACCESS_DENIED_ERROR: int
+RELAY_LOG_FAIL: int
+PASSWD_LENGTH: int
+UNKNOWN_TARGET_BINLOG: int
+IO_ERR_LOG_INDEX_READ: int
+BINLOG_PURGE_PROHIBITED: int
+FSEEK_FAIL: int
+BINLOG_PURGE_FATAL_ERR: int
+LOG_IN_USE: int
+LOG_PURGE_UNKNOWN_ERR: int
+RELAY_LOG_INIT: int
+NO_BINARY_LOGGING: int
+RESERVED_SYNTAX: int
+WSAS_FAILED: int
+DIFF_GROUPS_PROC: int
+NO_GROUP_FOR_PROC: int
+ORDER_WITH_PROC: int
+LOGGING_PROHIBIT_CHANGING_OF: int
+NO_FILE_MAPPING: int
+WRONG_MAGIC: int
+PS_MANY_PARAM: int
+KEY_PART_0: int
+VIEW_CHECKSUM: int
+VIEW_MULTIUPDATE: int
+VIEW_NO_INSERT_FIELD_LIST: int
+VIEW_DELETE_MERGE_VIEW: int
+CANNOT_USER: int
+XAER_NOTA: int
+XAER_INVAL: int
+XAER_RMFAIL: int
+XAER_OUTSIDE: int
+XAER_RMERR: int
+XA_RBROLLBACK: int
+NONEXISTING_PROC_GRANT: int
+PROC_AUTO_GRANT_FAIL: int
+PROC_AUTO_REVOKE_FAIL: int
+DATA_TOO_LONG: int
+SP_BAD_SQLSTATE: int
+STARTUP: int
+LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR: int
+CANT_CREATE_USER_WITH_GRANT: int
+WRONG_VALUE_FOR_TYPE: int
+TABLE_DEF_CHANGED: int
+SP_DUP_HANDLER: int
+SP_NOT_VAR_ARG: int
+SP_NO_RETSET: int
+CANT_CREATE_GEOMETRY_OBJECT: int
+FAILED_ROUTINE_BREAK_BINLOG: int
+BINLOG_UNSAFE_ROUTINE: int
+BINLOG_CREATE_ROUTINE_NEED_SUPER: int
+EXEC_STMT_WITH_OPEN_CURSOR: int
+STMT_HAS_NO_OPEN_CURSOR: int
+COMMIT_NOT_ALLOWED_IN_SF_OR_TRG: int
+NO_DEFAULT_FOR_VIEW_FIELD: int
+SP_NO_RECURSION: int
+TOO_BIG_SCALE: int
+TOO_BIG_PRECISION: int
+M_BIGGER_THAN_D: int
+WRONG_LOCK_OF_SYSTEM_TABLE: int
+CONNECT_TO_FOREIGN_DATA_SOURCE: int
+QUERY_ON_FOREIGN_DATA_SOURCE: int
+FOREIGN_DATA_SOURCE_DOESNT_EXIST: int
+FOREIGN_DATA_STRING_INVALID_CANT_CREATE: int
+FOREIGN_DATA_STRING_INVALID: int
+CANT_CREATE_FEDERATED_TABLE: int
+TRG_IN_WRONG_SCHEMA: int
+STACK_OVERRUN_NEED_MORE: int
+TOO_LONG_BODY: int
+WARN_CANT_DROP_DEFAULT_KEYCACHE: int
+TOO_BIG_DISPLAYWIDTH: int
+XAER_DUPID: int
+DATETIME_FUNCTION_OVERFLOW: int
+CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG: int
+VIEW_PREVENT_UPDATE: int
+PS_NO_RECURSION: int
+SP_CANT_SET_AUTOCOMMIT: int
+MALFORMED_DEFINER: int
+VIEW_FRM_NO_USER: int
+VIEW_OTHER_USER: int
+NO_SUCH_USER: int
+FORBID_SCHEMA_CHANGE: int
+ROW_IS_REFERENCED_2: int
+NO_REFERENCED_ROW_2: int
+SP_BAD_VAR_SHADOW: int
+TRG_NO_DEFINER: int
+OLD_FILE_FORMAT: int
+SP_RECURSION_LIMIT: int
+SP_PROC_TABLE_CORRUPT: int
+SP_WRONG_NAME: int
+TABLE_NEEDS_UPGRADE: int
+SP_NO_AGGREGATE: int
+MAX_PREPARED_STMT_COUNT_REACHED: int
+VIEW_RECURSIVE: int
+NON_GROUPING_FIELD_USED: int
+TABLE_CANT_HANDLE_SPKEYS: int
+NO_TRIGGERS_ON_SYSTEM_SCHEMA: int
+USERNAME: int
+HOSTNAME: int
+WRONG_STRING_LENGTH: int
+ERROR_LAST: int

shared/package-files/d0/d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8/blob

@@ -0,0 +1 @@
+conda

shared/package-files/d0/d0eee1c38f9d55f010da652848b6e35986a448dcdcbfa07a9f20490913da8dda/blob

@@ -0,0 +1,16 @@
+"""
+Usecases with Python 3 function annotations.  This is a separate module
+in order to avoid syntax errors with Python 2.
+"""
+
+
+class AnnotatedClass:
+    """
+    A class with annotated methods.
+    """
+
+    def __init__(self, v: int):
+        self.x = v
+
+    def add(self, v: int) -> int:
+        return self.x + v

shared/package-files/d0/d0f0ef33cabf63d34196cea674752b86f99e4969f479d591419a2cf6ff022741/blob

@@ -0,0 +1,445 @@
+# mypy: ignore-errors
+
+import torch.fx as fx
+import copy
+import torch
+import math
+import sys
+from typing import Callable, List
+from functools import wraps, partial
+from dataclasses import dataclass
+from .compile_utils import get_placeholders, get_outputs
+from torch.utils._content_store import ContentStoreWriter
+from torch.hub import tqdm
+from torch.multiprocessing.reductions import StorageWeakRef
+import os
+
+is_tuple = object()
+
+@dataclass
+class LoadTensorMeta:
+    size: List[int]
+    stride: List[int]
+    dtype: torch.dtype
+    device: torch.device
+
+class ConcreteProp(torch.fx.Interpreter):
+    def __init__(self, mod, *, writer=None, skip_offload=False):
+        super().__init__(mod)
+        self.writer = writer
+        self.skip_offload = skip_offload
+        self.seen_storages = set()
+
+    def run_node(self, n):
+        self.pbar.update(1)
+        r = super().run_node(n)
+        name = n.name
+
+        if isinstance(r, torch.Tensor):
+            if self.writer is None:
+                n.meta['concrete_value'] = r
+            else:
+                if StorageWeakRef(r.untyped_storage()) in self.seen_storages:
+                    # Refuse to offload tensors which alias other live
+                    # tensors, because this will violate operator contracts
+                    n.meta['concrete_value'] = None
+                else:
+                    if not self.skip_offload:
+                        self.writer.write_tensor(os.path.join("eager", name), r)
+                    n.meta['concrete_value'] = LoadTensorMeta(
+                        r.size(),
+                        r.stride(),
+                        r.dtype,
+                        r.device
+                    )
+                    self.seen_storages.add(StorageWeakRef(r.untyped_storage()))
+        else:
+            n.meta['concrete_value'] = is_tuple
+
+        return r
+
+    def propagate(self, *args):
+        with tqdm(
+            desc="Saving intermediates for delta debugging",
+            total=len(self.module.graph.nodes),
+            disable=self.writer is None
+        ) as pbar:
+            self.pbar = pbar
+            r = super().run(*args)
+            if not self.skip_offload:
+                pbar.set_description("Saved!  To skip next time, run with --skip-saving-eager-intermediates")
+            return r
+
+def is_load_tensor_node(node):
+    return node.op == 'call_function' and node.target is torch.ops.debugprims.load_tensor.default
+
+
+# inplace modifies node/inps
+def _convert_node_to_placeholder(graph, node, inps):
+    if node.op == 'output' or node.op == "placeholder":
+        return False
+
+    if is_load_tensor_node(node):
+        return False
+
+    concrete_val = node.meta.get('concrete_value', None)
+
+    if isinstance(concrete_val, torch.Tensor):
+        node.op = 'placeholder'
+        node.target = node.name
+        node.args = ()
+        node.kwargs = {}
+
+        inps.append(concrete_val)
+        return True
+
+    elif concrete_val is None:
+        return False
+
+    elif concrete_val is is_tuple:
+        r = False
+        for tuple_user in list(node.users):
+            r = _convert_node_to_placeholder(graph, tuple_user, inps) or r
+        # NB: We must not erase the node at this point, because
+        # we are iterating over the nodes and this would change
+        # the iteration order
+        # graph.erase_node(node)
+        return r
+
+    elif isinstance(concrete_val, LoadTensorMeta):
+        node.op = 'call_function'
+        node.target = torch.ops.debugprims.load_tensor.default
+        node.args = (os.path.join("eager", node.name), concrete_val.size, concrete_val.stride)
+        node.kwargs = {
+            'device': concrete_val.device,
+            'dtype': concrete_val.dtype,
+        }
+        return True
+
+    return False
+
+def create_minified_hlo_graph(minified_fx_graph, inputs):
+    """
+    Takes minified FX graph as primary input, and ports it to HLO via StableHLO
+    Provides minified HLO graph as output, and archive them to local directory
+    """
+    hlo_dir = f"{os.getcwd()}/hlo_files"
+    os.makedirs(hlo_dir, exists_ok=True)
+
+    from torch_xla.stablehlo import save_torch_model_as_stablehlo
+    save_torch_model_as_stablehlo(minified_fx_graph, inputs, hlo_dir)
+
+def dump_state(fx_g, inps):
+    print(f"""
+# Working Repro with {len(fx_g.graph.nodes)} nodes
+inps = {[(i.shape, i.dtype, i.device.type) for i in inps]}
+inps = [torch.zeros(())] + [torch.ones(shape, dtype=dtype, device=device) for (shape, dtype, device) in inps]
+{fx_g.code}
+""")
+
+def is_power_of_two(n):
+    if n == 0:
+        return False
+    return (n & (n - 1)) == 0
+
+@dataclass
+class ReproState:
+    graph: fx.Graph
+    inps: List[torch.Tensor]
+
+    def __post_init__(self):
+        ph_nodes = get_placeholders(self.graph)
+        assert len(ph_nodes) == len(self.inps)
+
+def minifier(
+    fail_f: fx.GraphModule, inps, module_fails, dump_state: Callable = dump_state, *,
+    save_dir=None, offload_to_disk=False, skip_offload=False, skip_sanity=False,
+    max_granularity=None
+):
+    """
+    Minimizes a FX graph with given inputs, such that the resulting FX graph still returns True for module_fails.
+
+    Does 2 main strategies:
+    1. Truncates suffix: Removes some suffix from the graph and sets a new output.
+    2. Delta Debugging: Tries replacing half of the graph with inputs. If fails,
+        tries replacing quarter of the graph, etc.
+
+    >>> # xdoctest: +SKIP(failing)
+    >>> failing_function = fx.symbolic_trace(f)
+    >>> minimize(failing_function, [torch.randn(5)], lambda fx_g, inps: fx_g(*inps))
+
+    note: module_fails returns True if it fails.
+    """
+    assert isinstance(inps, (tuple, list))
+
+    failing_graph = fail_f.graph
+    cur_size = len(failing_graph.nodes)
+
+    if max_granularity is not None and not is_power_of_two(max_granularity):
+        raise RuntimeError(f"max_granularity {max_granularity} not power of two")
+
+    num_queries = 0
+
+    def deepcopy_fx_graph(fx_graph):
+        return fx.GraphModule(fail_f, copy.deepcopy(fx_graph)).graph
+
+
+    def graph_fails(graph, inps):
+        nonlocal num_queries
+        graph = copy.deepcopy(graph)
+        num_queries += 1
+        mod = fx.GraphModule(fail_f, graph)
+        mod.graph.lint()
+        return module_fails(mod, inps)
+
+    writer = None
+    if offload_to_disk:
+        writer = ContentStoreWriter(save_dir)
+
+    ConcreteProp(fail_f, writer=writer, skip_offload=skip_offload).propagate(*inps)
+    if not skip_sanity and not graph_fails(failing_graph, inps):
+        raise RuntimeError("Input graph did not fail the tester")
+    print(f"Started off with {cur_size} nodes", file=sys.stderr)
+
+    def _register_strategy(strategy: Callable, name: str):
+        @wraps(strategy)
+        def new_func(old_state: ReproState, granularity=1):
+            print(file=sys.stderr)
+            print(
+                f"Strategy: {name} (G: {granularity}) "
+                f"({len(old_state.graph.nodes)} nodes, {len(old_state.inps)} inputs)",
+                file=sys.stderr
+            )
+            new_state = strategy(deepcopy_fx_graph(old_state.graph), list(old_state.inps), granularity)
+            if new_state is not None:
+                new_nodes = len(new_state.graph.nodes)
+                old_nodes = len(old_state.graph.nodes)
+                new_inps = len(new_state.inps)
+                old_inps = len(old_state.inps)
+                new_outs = len(get_outputs(new_state.graph))
+                old_outs = len(get_outputs(old_state.graph))
+                progress_made = False
+                if new_nodes < old_nodes:
+                    progress_made = True
+                    print(f"SUCCESS: Went from {old_nodes} to {new_nodes} nodes", file=sys.stderr)
+                if new_inps > old_inps:
+                    progress_made = True
+                    print(f"SUCCESS: Went from {old_inps} to {new_inps} inputs", file=sys.stderr)
+                if new_outs < old_outs:
+                    progress_made = True
+                    print(f"SUCCESS: Went from {old_outs} to {new_outs} outputs", file=sys.stderr)
+
+                if not progress_made:
+                    raise RuntimeError("Success raised but no progress made?")
+
+                if not graph_fails(new_state.graph, new_state.inps):
+                    print("WARNING: Something went wrong, not applying this minification", file=sys.stderr)
+                    return None
+                return new_state
+            else:
+                print(f"FAIL: {name}", file=sys.stderr)
+            return None
+
+        return new_func
+
+    def register_strategy(name: str):
+        return partial(_register_strategy, name=name)
+
+    @register_strategy("Truncate suffix")
+    def remove_suffix(cur_graph, cur_inps, granularity):
+        tested = set()
+        new_graph = fx.Graph()
+        env = {}
+        for idx, node in enumerate(cur_graph.nodes):
+            new_node = new_graph.node_copy(node, lambda x: env[x])
+            if node.op not in ['placeholder', 'output']:
+                # If idx is divisible by (granularity * 2), it would have been checked already.
+                if idx % granularity == 0 and (idx % (granularity * 2) != 0) and idx not in tested:
+                    output_node = new_graph.output((new_node,))
+                    if len(new_graph.nodes) < len(cur_graph.nodes) and graph_fails(new_graph, cur_inps):
+                        return ReproState(new_graph, cur_inps)
+                    else:
+                        tested.add(idx)
+                        new_graph.erase_node(output_node)
+            env[node] = new_node
+        return None
+
+    @register_strategy("Remove outputs")
+    def remove_outputs(cur_graph, cur_inps, granularity):
+        granularity = max(1, granularity // 2)
+        for idx, node in enumerate(cur_graph.nodes):
+            node.idx = idx
+            if node.op == 'output':
+                output = node
+                break
+
+        if isinstance(output.args[0], fx.Node):
+            return None
+
+        output_args = sorted(output.args[0], key=lambda x: x.idx if isinstance(x, fx.Node) else int(1e9))
+        if len(output_args) == 1:
+            return None
+
+        for idx in range(0, len(output_args), granularity):
+            output.args = (output_args[:idx] + output_args[idx + granularity:],)
+            if graph_fails(cur_graph, cur_inps):
+                return ReproState(cur_graph, cur_inps)
+        return None
+
+
+    def remove_unused_inputs_unchecked(cur_state: ReproState):
+        cur_graph = cur_state.graph
+        cur_inps = cur_state.inps
+        ph_nodes = get_placeholders(cur_graph)
+        assert len(ph_nodes) == len(cur_inps)
+
+        new_inps = []
+        for idx in range(len(ph_nodes)):
+            if len(ph_nodes[idx].users) == 0:
+                cur_graph.erase_node(ph_nodes[idx])
+            else:
+                new_inps.append(cur_inps[idx])
+        if len(new_inps) < len(cur_inps):
+            return ReproState(cur_graph, new_inps)
+        return None
+
+    def remove_unused_inputs_checked(cur_state: ReproState):
+        new_state = remove_unused_inputs_unchecked(cur_state)
+        if new_state is not None and graph_fails(new_state.graph, new_state.inps):
+            return new_state
+        return None
+
+    def _remove_unused_wrapper(cur_graph, cur_inps, granularity):
+        return remove_unused_inputs_checked(ReproState(cur_graph, cur_inps))
+
+    remove_unused_inputs = register_strategy("Remove unused inputs")(_remove_unused_wrapper)
+
+    @register_strategy("Eliminate dead code")
+    def eliminate_dead_code(cur_graph, cur_inps, granularity):
+        if cur_graph.eliminate_dead_code() and graph_fails(cur_graph, cur_inps):
+            return ReproState(cur_graph, cur_inps)
+        return None
+
+
+    def _consolidate_placeholders(cur_graph, inps):
+        new_graph = fx.Graph()
+        env = {}
+        seen_non_placeholder = False
+
+        # Move all placeholders to the front; also, if any load_tensor
+        # is at the front, convert it into an input (because it can be live
+        # all the time)
+        for node in cur_graph.nodes:
+            if node.op == 'placeholder':
+                new_node = new_graph.node_copy(node, lambda x: env[x])
+                env[node] = new_node
+            elif not seen_non_placeholder and is_load_tensor_node(node):
+                new_node = new_graph.placeholder(node.name)
+                env[node] = new_node
+                inps.append(torch.ops.debugprims.load_tensor.default(*node.args, **node.kwargs))
+            else:
+                seen_non_placeholder = True
+
+        # Move everyone else
+        for node in cur_graph.nodes:
+            if node not in env:
+                new_node = new_graph.node_copy(node, lambda x: env[x])
+                env[node] = new_node
+        return new_graph
+
+    @register_strategy("Delta Debugging")
+    def delta_debugging(cur_graph: fx.Graph, cur_inps, granularity):
+        num_nodes = len(cur_graph.nodes)
+        for start_range in range(0, num_nodes, granularity):
+            is_removing = False
+            new_graph = deepcopy_fx_graph(cur_graph)
+            new_inps = cur_inps[:]
+            end_range = min(num_nodes, start_range + granularity)
+            for idx in range(start_range, end_range):
+                new_node = list(new_graph.nodes)[idx]
+                if _convert_node_to_placeholder(new_graph, new_node, new_inps):
+                    is_removing = True
+            if not is_removing:
+                continue
+            new_graph.eliminate_dead_code()
+            new_graph = _consolidate_placeholders(new_graph, new_inps)
+            new_state = remove_unused_inputs_unchecked(ReproState(new_graph, new_inps))
+            if new_state is None:
+                new_state = ReproState(new_graph, new_inps)
+            if graph_fails(new_state.graph, new_state.inps):
+                return ReproState(new_state.graph, new_state.inps)
+
+        return None
+
+    @register_strategy("Consolidate Inputs")
+    def consolidate_inputs(cur_graph, cur_inps, granularity):
+        old_len = len(cur_inps)
+        cur_graph = _consolidate_placeholders(cur_graph, cur_inps)
+        if len(cur_inps) > old_len and graph_fails(cur_graph, cur_inps):
+            return ReproState(cur_graph, cur_inps)
+        return None
+
+    failing_state = ReproState(failing_graph, inps)
+
+    def try_granularity(failing_state, granularity, use_non_granular):
+        print(f"Trying granularity {granularity}", file=sys.stderr)
+
+        strategies = []
+        num_nodes = len(failing_state.graph.nodes)
+        num_outputs = len(get_outputs(failing_state.graph))
+        if num_outputs > num_nodes // 2:
+            strategies += [remove_outputs]
+
+        if use_non_granular:
+            strategies += [eliminate_dead_code, remove_unused_inputs, consolidate_inputs]
+
+        strategies += [remove_suffix, delta_debugging]
+
+        for strategy in strategies:
+            new_state = strategy(failing_state, granularity)
+            if new_state is not None:
+                return new_state
+        return None
+
+    while True:
+        dump_state(fx.GraphModule(fail_f, failing_state.graph), failing_state.inps)
+        granularity = int(2**(math.floor(math.log2(len(failing_state.graph.nodes)))))
+        if max_granularity is not None:
+            granularity = min(max_granularity, granularity)
+        new_state = try_granularity(failing_state, granularity, use_non_granular=True)
+        if new_state is not None:
+            failing_state = new_state
+            continue
+
+        granularity //= 2
+        has_progress = False
+        while granularity >= 1:
+            new_state = try_granularity(failing_state, granularity, use_non_granular=False)
+            if new_state is not None:
+                failing_state = new_state
+                has_progress = True
+                break
+            granularity //= 2
+        if has_progress:
+            continue
+
+        new_state = remove_outputs(failing_state, 1)
+        if new_state is not None:
+            failing_state = new_state
+            continue
+
+        break
+
+    if not graph_fails(failing_state.graph, failing_state.inps):
+        raise RuntimeError("Uh oh, something went wrong :( Final graph is not failing")
+
+    print(f"Made {num_queries} queries", file=sys.stderr)
+    failing_fx = fx.GraphModule(fail_f, failing_state.graph)
+
+    # If XLA debugging environment is enabled, create minified HLO graph as well
+    if "XLA_HLO_DEBUG" in os.environ:
+        create_minified_hlo_graph(failing_fx, failing_state.inps)
+
+    dump_state(failing_fx, failing_state.inps)
+    print("Wrote minimal repro out to repro.py", file=sys.stderr)
+    return failing_fx, failing_state.inps

shared/package-files/d0/d0f3670ea2a4a2467b11154381b7acf0a35973e21226b65495565ce4b916d7c1/blob

@@ -0,0 +1,1375 @@
+dtype,input,output,ulperrortol
+## +ve denormals ##
+np.float32,0x004b4716,0x3f800000,2
+np.float32,0x007b2490,0x3f800000,2
+np.float32,0x007c99fa,0x3f800000,2
+np.float32,0x00734a0c,0x3f800000,2
+np.float32,0x0070de24,0x3f800000,2
+np.float32,0x007fffff,0x3f800000,2
+np.float32,0x00000001,0x3f800000,2
+## -ve denormals ##
+np.float32,0x80495d65,0x3f800000,2
+np.float32,0x806894f6,0x3f800000,2
+np.float32,0x80555a76,0x3f800000,2
+np.float32,0x804e1fb8,0x3f800000,2
+np.float32,0x80687de9,0x3f800000,2
+np.float32,0x807fffff,0x3f800000,2
+np.float32,0x80000001,0x3f800000,2
+## +/-0.0f, +/-FLT_MIN +/-FLT_MAX ##
+np.float32,0x00000000,0x3f800000,2
+np.float32,0x80000000,0x3f800000,2
+np.float32,0x00800000,0x3f800000,2
+np.float32,0x80800000,0x3f800000,2
+## 1.00f + 0x00000001 ##
+np.float32,0x3f800000,0x3f0a5140,2
+np.float32,0x3f800001,0x3f0a513f,2
+np.float32,0x3f800002,0x3f0a513d,2
+np.float32,0xc090a8b0,0xbe4332ce,2
+np.float32,0x41ce3184,0x3f4d1de1,2
+np.float32,0xc1d85848,0xbeaa8980,2
+np.float32,0x402b8820,0xbf653aa3,2
+np.float32,0x42b4e454,0xbf4a338b,2
+np.float32,0x42a67a60,0x3c58202e,2
+np.float32,0x41d92388,0xbed987c7,2
+np.float32,0x422dd66c,0x3f5dcab3,2
+np.float32,0xc28f5be6,0xbf5688d8,2
+np.float32,0x41ab2674,0xbf53aa3b,2
+np.float32,0x3f490fdb,0x3f3504f3,2
+np.float32,0xbf490fdb,0x3f3504f3,2
+np.float32,0x3fc90fdb,0xb33bbd2e,2
+np.float32,0xbfc90fdb,0xb33bbd2e,2
+np.float32,0x40490fdb,0xbf800000,2
+np.float32,0xc0490fdb,0xbf800000,2
+np.float32,0x3fc90fdb,0xb33bbd2e,2
+np.float32,0xbfc90fdb,0xb33bbd2e,2
+np.float32,0x40490fdb,0xbf800000,2
+np.float32,0xc0490fdb,0xbf800000,2
+np.float32,0x40c90fdb,0x3f800000,2
+np.float32,0xc0c90fdb,0x3f800000,2
+np.float32,0x4016cbe4,0xbf3504f3,2
+np.float32,0xc016cbe4,0xbf3504f3,2
+np.float32,0x4096cbe4,0x324cde2e,2
+np.float32,0xc096cbe4,0x324cde2e,2
+np.float32,0x4116cbe4,0xbf800000,2
+np.float32,0xc116cbe4,0xbf800000,2
+np.float32,0x40490fdb,0xbf800000,2
+np.float32,0xc0490fdb,0xbf800000,2
+np.float32,0x40c90fdb,0x3f800000,2
+np.float32,0xc0c90fdb,0x3f800000,2
+np.float32,0x41490fdb,0x3f800000,2
+np.float32,0xc1490fdb,0x3f800000,2
+np.float32,0x407b53d2,0xbf3504f1,2
+np.float32,0xc07b53d2,0xbf3504f1,2
+np.float32,0x40fb53d2,0xb4b5563d,2
+np.float32,0xc0fb53d2,0xb4b5563d,2
+np.float32,0x417b53d2,0xbf800000,2
+np.float32,0xc17b53d2,0xbf800000,2
+np.float32,0x4096cbe4,0x324cde2e,2
+np.float32,0xc096cbe4,0x324cde2e,2
+np.float32,0x4116cbe4,0xbf800000,2
+np.float32,0xc116cbe4,0xbf800000,2
+np.float32,0x4196cbe4,0x3f800000,2
+np.float32,0xc196cbe4,0x3f800000,2
+np.float32,0x40afede0,0x3f3504f7,2
+np.float32,0xc0afede0,0x3f3504f7,2
+np.float32,0x412fede0,0x353222c4,2
+np.float32,0xc12fede0,0x353222c4,2
+np.float32,0x41afede0,0xbf800000,2
+np.float32,0xc1afede0,0xbf800000,2
+np.float32,0x40c90fdb,0x3f800000,2
+np.float32,0xc0c90fdb,0x3f800000,2
+np.float32,0x41490fdb,0x3f800000,2
+np.float32,0xc1490fdb,0x3f800000,2
+np.float32,0x41c90fdb,0x3f800000,2
+np.float32,0xc1c90fdb,0x3f800000,2
+np.float32,0x40e231d6,0x3f3504f3,2
+np.float32,0xc0e231d6,0x3f3504f3,2
+np.float32,0x416231d6,0xb319a6a2,2
+np.float32,0xc16231d6,0xb319a6a2,2
+np.float32,0x41e231d6,0xbf800000,2
+np.float32,0xc1e231d6,0xbf800000,2
+np.float32,0x40fb53d2,0xb4b5563d,2
+np.float32,0xc0fb53d2,0xb4b5563d,2
+np.float32,0x417b53d2,0xbf800000,2
+np.float32,0xc17b53d2,0xbf800000,2
+np.float32,0x41fb53d2,0x3f800000,2
+np.float32,0xc1fb53d2,0x3f800000,2
+np.float32,0x410a3ae7,0xbf3504fb,2
+np.float32,0xc10a3ae7,0xbf3504fb,2
+np.float32,0x418a3ae7,0x35b08908,2
+np.float32,0xc18a3ae7,0x35b08908,2
+np.float32,0x420a3ae7,0xbf800000,2
+np.float32,0xc20a3ae7,0xbf800000,2
+np.float32,0x4116cbe4,0xbf800000,2
+np.float32,0xc116cbe4,0xbf800000,2
+np.float32,0x4196cbe4,0x3f800000,2
+np.float32,0xc196cbe4,0x3f800000,2
+np.float32,0x4216cbe4,0x3f800000,2
+np.float32,0xc216cbe4,0x3f800000,2
+np.float32,0x41235ce2,0xbf3504ef,2
+np.float32,0xc1235ce2,0xbf3504ef,2
+np.float32,0x41a35ce2,0xb53889b6,2
+np.float32,0xc1a35ce2,0xb53889b6,2
+np.float32,0x42235ce2,0xbf800000,2
+np.float32,0xc2235ce2,0xbf800000,2
+np.float32,0x412fede0,0x353222c4,2
+np.float32,0xc12fede0,0x353222c4,2
+np.float32,0x41afede0,0xbf800000,2
+np.float32,0xc1afede0,0xbf800000,2
+np.float32,0x422fede0,0x3f800000,2
+np.float32,0xc22fede0,0x3f800000,2
+np.float32,0x413c7edd,0x3f3504f4,2
+np.float32,0xc13c7edd,0x3f3504f4,2
+np.float32,0x41bc7edd,0x33800add,2
+np.float32,0xc1bc7edd,0x33800add,2
+np.float32,0x423c7edd,0xbf800000,2
+np.float32,0xc23c7edd,0xbf800000,2
+np.float32,0x41490fdb,0x3f800000,2
+np.float32,0xc1490fdb,0x3f800000,2
+np.float32,0x41c90fdb,0x3f800000,2
+np.float32,0xc1c90fdb,0x3f800000,2
+np.float32,0x42490fdb,0x3f800000,2
+np.float32,0xc2490fdb,0x3f800000,2
+np.float32,0x4155a0d9,0x3f3504eb,2
+np.float32,0xc155a0d9,0x3f3504eb,2
+np.float32,0x41d5a0d9,0xb5b3bc81,2
+np.float32,0xc1d5a0d9,0xb5b3bc81,2
+np.float32,0x4255a0d9,0xbf800000,2
+np.float32,0xc255a0d9,0xbf800000,2
+np.float32,0x416231d6,0xb319a6a2,2
+np.float32,0xc16231d6,0xb319a6a2,2
+np.float32,0x41e231d6,0xbf800000,2
+np.float32,0xc1e231d6,0xbf800000,2
+np.float32,0x426231d6,0x3f800000,2
+np.float32,0xc26231d6,0x3f800000,2
+np.float32,0x416ec2d4,0xbf3504f7,2
+np.float32,0xc16ec2d4,0xbf3504f7,2
+np.float32,0x41eec2d4,0x353ef0a7,2
+np.float32,0xc1eec2d4,0x353ef0a7,2
+np.float32,0x426ec2d4,0xbf800000,2
+np.float32,0xc26ec2d4,0xbf800000,2
+np.float32,0x417b53d2,0xbf800000,2
+np.float32,0xc17b53d2,0xbf800000,2
+np.float32,0x41fb53d2,0x3f800000,2
+np.float32,0xc1fb53d2,0x3f800000,2
+np.float32,0x427b53d2,0x3f800000,2
+np.float32,0xc27b53d2,0x3f800000,2
+np.float32,0x4183f268,0xbf3504e7,2
+np.float32,0xc183f268,0xbf3504e7,2
+np.float32,0x4203f268,0xb6059a13,2
+np.float32,0xc203f268,0xb6059a13,2
+np.float32,0x4283f268,0xbf800000,2
+np.float32,0xc283f268,0xbf800000,2
+np.float32,0x418a3ae7,0x35b08908,2
+np.float32,0xc18a3ae7,0x35b08908,2
+np.float32,0x420a3ae7,0xbf800000,2
+np.float32,0xc20a3ae7,0xbf800000,2
+np.float32,0x428a3ae7,0x3f800000,2
+np.float32,0xc28a3ae7,0x3f800000,2
+np.float32,0x41908365,0x3f3504f0,2
+np.float32,0xc1908365,0x3f3504f0,2
+np.float32,0x42108365,0xb512200d,2
+np.float32,0xc2108365,0xb512200d,2
+np.float32,0x42908365,0xbf800000,2
+np.float32,0xc2908365,0xbf800000,2
+np.float32,0x4196cbe4,0x3f800000,2
+np.float32,0xc196cbe4,0x3f800000,2
+np.float32,0x4216cbe4,0x3f800000,2
+np.float32,0xc216cbe4,0x3f800000,2
+np.float32,0x4296cbe4,0x3f800000,2
+np.float32,0xc296cbe4,0x3f800000,2
+np.float32,0x419d1463,0x3f3504ef,2
+np.float32,0xc19d1463,0x3f3504ef,2
+np.float32,0x421d1463,0xb5455799,2
+np.float32,0xc21d1463,0xb5455799,2
+np.float32,0x429d1463,0xbf800000,2
+np.float32,0xc29d1463,0xbf800000,2
+np.float32,0x41a35ce2,0xb53889b6,2
+np.float32,0xc1a35ce2,0xb53889b6,2
+np.float32,0x42235ce2,0xbf800000,2
+np.float32,0xc2235ce2,0xbf800000,2
+np.float32,0x42a35ce2,0x3f800000,2
+np.float32,0xc2a35ce2,0x3f800000,2
+np.float32,0x41a9a561,0xbf3504ff,2
+np.float32,0xc1a9a561,0xbf3504ff,2
+np.float32,0x4229a561,0x360733d0,2
+np.float32,0xc229a561,0x360733d0,2
+np.float32,0x42a9a561,0xbf800000,2
+np.float32,0xc2a9a561,0xbf800000,2
+np.float32,0x41afede0,0xbf800000,2
+np.float32,0xc1afede0,0xbf800000,2
+np.float32,0x422fede0,0x3f800000,2
+np.float32,0xc22fede0,0x3f800000,2
+np.float32,0x42afede0,0x3f800000,2
+np.float32,0xc2afede0,0x3f800000,2
+np.float32,0x41b6365e,0xbf3504f6,2
+np.float32,0xc1b6365e,0xbf3504f6,2
+np.float32,0x4236365e,0x350bb91c,2
+np.float32,0xc236365e,0x350bb91c,2
+np.float32,0x42b6365e,0xbf800000,2
+np.float32,0xc2b6365e,0xbf800000,2
+np.float32,0x41bc7edd,0x33800add,2
+np.float32,0xc1bc7edd,0x33800add,2
+np.float32,0x423c7edd,0xbf800000,2
+np.float32,0xc23c7edd,0xbf800000,2
+np.float32,0x42bc7edd,0x3f800000,2
+np.float32,0xc2bc7edd,0x3f800000,2
+np.float32,0x41c2c75c,0x3f3504f8,2
+np.float32,0xc1c2c75c,0x3f3504f8,2
+np.float32,0x4242c75c,0x354bbe8a,2
+np.float32,0xc242c75c,0x354bbe8a,2
+np.float32,0x42c2c75c,0xbf800000,2
+np.float32,0xc2c2c75c,0xbf800000,2
+np.float32,0x41c90fdb,0x3f800000,2
+np.float32,0xc1c90fdb,0x3f800000,2
+np.float32,0x42490fdb,0x3f800000,2
+np.float32,0xc2490fdb,0x3f800000,2
+np.float32,0x42c90fdb,0x3f800000,2
+np.float32,0xc2c90fdb,0x3f800000,2
+np.float32,0x41cf585a,0x3f3504e7,2
+np.float32,0xc1cf585a,0x3f3504e7,2
+np.float32,0x424f585a,0xb608cd8c,2
+np.float32,0xc24f585a,0xb608cd8c,2
+np.float32,0x42cf585a,0xbf800000,2
+np.float32,0xc2cf585a,0xbf800000,2
+np.float32,0x41d5a0d9,0xb5b3bc81,2
+np.float32,0xc1d5a0d9,0xb5b3bc81,2
+np.float32,0x4255a0d9,0xbf800000,2
+np.float32,0xc255a0d9,0xbf800000,2
+np.float32,0x42d5a0d9,0x3f800000,2
+np.float32,0xc2d5a0d9,0x3f800000,2
+np.float32,0x41dbe958,0xbf350507,2
+np.float32,0xc1dbe958,0xbf350507,2
+np.float32,0x425be958,0x365eab75,2
+np.float32,0xc25be958,0x365eab75,2
+np.float32,0x42dbe958,0xbf800000,2
+np.float32,0xc2dbe958,0xbf800000,2
+np.float32,0x41e231d6,0xbf800000,2
+np.float32,0xc1e231d6,0xbf800000,2
+np.float32,0x426231d6,0x3f800000,2
+np.float32,0xc26231d6,0x3f800000,2
+np.float32,0x42e231d6,0x3f800000,2
+np.float32,0xc2e231d6,0x3f800000,2
+np.float32,0x41e87a55,0xbf3504ef,2
+np.float32,0xc1e87a55,0xbf3504ef,2
+np.float32,0x42687a55,0xb552257b,2
+np.float32,0xc2687a55,0xb552257b,2
+np.float32,0x42e87a55,0xbf800000,2
+np.float32,0xc2e87a55,0xbf800000,2
+np.float32,0x41eec2d4,0x353ef0a7,2
+np.float32,0xc1eec2d4,0x353ef0a7,2
+np.float32,0x426ec2d4,0xbf800000,2
+np.float32,0xc26ec2d4,0xbf800000,2
+np.float32,0x42eec2d4,0x3f800000,2
+np.float32,0xc2eec2d4,0x3f800000,2
+np.float32,0x41f50b53,0x3f3504ff,2
+np.float32,0xc1f50b53,0x3f3504ff,2
+np.float32,0x42750b53,0x360a6748,2
+np.float32,0xc2750b53,0x360a6748,2
+np.float32,0x42f50b53,0xbf800000,2
+np.float32,0xc2f50b53,0xbf800000,2
+np.float32,0x41fb53d2,0x3f800000,2
+np.float32,0xc1fb53d2,0x3f800000,2
+np.float32,0x427b53d2,0x3f800000,2
+np.float32,0xc27b53d2,0x3f800000,2
+np.float32,0x42fb53d2,0x3f800000,2
+np.float32,0xc2fb53d2,0x3f800000,2
+np.float32,0x4200ce28,0x3f3504f6,2
+np.float32,0xc200ce28,0x3f3504f6,2
+np.float32,0x4280ce28,0x34fdd672,2
+np.float32,0xc280ce28,0x34fdd672,2
+np.float32,0x4300ce28,0xbf800000,2
+np.float32,0xc300ce28,0xbf800000,2
+np.float32,0x4203f268,0xb6059a13,2
+np.float32,0xc203f268,0xb6059a13,2
+np.float32,0x4283f268,0xbf800000,2
+np.float32,0xc283f268,0xbf800000,2
+np.float32,0x4303f268,0x3f800000,2
+np.float32,0xc303f268,0x3f800000,2
+np.float32,0x420716a7,0xbf3504f8,2
+np.float32,0xc20716a7,0xbf3504f8,2
+np.float32,0x428716a7,0x35588c6d,2
+np.float32,0xc28716a7,0x35588c6d,2
+np.float32,0x430716a7,0xbf800000,2
+np.float32,0xc30716a7,0xbf800000,2
+np.float32,0x420a3ae7,0xbf800000,2
+np.float32,0xc20a3ae7,0xbf800000,2
+np.float32,0x428a3ae7,0x3f800000,2
+np.float32,0xc28a3ae7,0x3f800000,2
+np.float32,0x430a3ae7,0x3f800000,2
+np.float32,0xc30a3ae7,0x3f800000,2
+np.float32,0x420d5f26,0xbf3504e7,2
+np.float32,0xc20d5f26,0xbf3504e7,2
+np.float32,0x428d5f26,0xb60c0105,2
+np.float32,0xc28d5f26,0xb60c0105,2
+np.float32,0x430d5f26,0xbf800000,2
+np.float32,0xc30d5f26,0xbf800000,2
+np.float32,0x42108365,0xb512200d,2
+np.float32,0xc2108365,0xb512200d,2
+np.float32,0x42908365,0xbf800000,2
+np.float32,0xc2908365,0xbf800000,2
+np.float32,0x43108365,0x3f800000,2
+np.float32,0xc3108365,0x3f800000,2
+np.float32,0x4213a7a5,0x3f350507,2
+np.float32,0xc213a7a5,0x3f350507,2
+np.float32,0x4293a7a5,0x3661deee,2
+np.float32,0xc293a7a5,0x3661deee,2
+np.float32,0x4313a7a5,0xbf800000,2
+np.float32,0xc313a7a5,0xbf800000,2
+np.float32,0x4216cbe4,0x3f800000,2
+np.float32,0xc216cbe4,0x3f800000,2
+np.float32,0x4296cbe4,0x3f800000,2
+np.float32,0xc296cbe4,0x3f800000,2
+np.float32,0x4316cbe4,0x3f800000,2
+np.float32,0xc316cbe4,0x3f800000,2
+np.float32,0x4219f024,0x3f3504d8,2
+np.float32,0xc219f024,0x3f3504d8,2
+np.float32,0x4299f024,0xb69bde6c,2
+np.float32,0xc299f024,0xb69bde6c,2
+np.float32,0x4319f024,0xbf800000,2
+np.float32,0xc319f024,0xbf800000,2
+np.float32,0x421d1463,0xb5455799,2
+np.float32,0xc21d1463,0xb5455799,2
+np.float32,0x429d1463,0xbf800000,2
+np.float32,0xc29d1463,0xbf800000,2
+np.float32,0x431d1463,0x3f800000,2
+np.float32,0xc31d1463,0x3f800000,2
+np.float32,0x422038a3,0xbf350516,2
+np.float32,0xc22038a3,0xbf350516,2
+np.float32,0x42a038a3,0x36c6cd61,2
+np.float32,0xc2a038a3,0x36c6cd61,2
+np.float32,0x432038a3,0xbf800000,2
+np.float32,0xc32038a3,0xbf800000,2
+np.float32,0x42235ce2,0xbf800000,2
+np.float32,0xc2235ce2,0xbf800000,2
+np.float32,0x42a35ce2,0x3f800000,2
+np.float32,0xc2a35ce2,0x3f800000,2
+np.float32,0x43235ce2,0x3f800000,2
+np.float32,0xc3235ce2,0x3f800000,2
+np.float32,0x42268121,0xbf3504f6,2
+np.float32,0xc2268121,0xbf3504f6,2
+np.float32,0x42a68121,0x34e43aac,2
+np.float32,0xc2a68121,0x34e43aac,2
+np.float32,0x43268121,0xbf800000,2
+np.float32,0xc3268121,0xbf800000,2
+np.float32,0x4229a561,0x360733d0,2
+np.float32,0xc229a561,0x360733d0,2
+np.float32,0x42a9a561,0xbf800000,2
+np.float32,0xc2a9a561,0xbf800000,2
+np.float32,0x4329a561,0x3f800000,2
+np.float32,0xc329a561,0x3f800000,2
+np.float32,0x422cc9a0,0x3f3504f8,2
+np.float32,0xc22cc9a0,0x3f3504f8,2
+np.float32,0x42acc9a0,0x35655a50,2
+np.float32,0xc2acc9a0,0x35655a50,2
+np.float32,0x432cc9a0,0xbf800000,2
+np.float32,0xc32cc9a0,0xbf800000,2
+np.float32,0x422fede0,0x3f800000,2
+np.float32,0xc22fede0,0x3f800000,2
+np.float32,0x42afede0,0x3f800000,2
+np.float32,0xc2afede0,0x3f800000,2
+np.float32,0x432fede0,0x3f800000,2
+np.float32,0xc32fede0,0x3f800000,2
+np.float32,0x4233121f,0x3f3504e7,2
+np.float32,0xc233121f,0x3f3504e7,2
+np.float32,0x42b3121f,0xb60f347d,2
+np.float32,0xc2b3121f,0xb60f347d,2
+np.float32,0x4333121f,0xbf800000,2
+np.float32,0xc333121f,0xbf800000,2
+np.float32,0x4236365e,0x350bb91c,2
+np.float32,0xc236365e,0x350bb91c,2
+np.float32,0x42b6365e,0xbf800000,2
+np.float32,0xc2b6365e,0xbf800000,2
+np.float32,0x4336365e,0x3f800000,2
+np.float32,0xc336365e,0x3f800000,2
+np.float32,0x42395a9e,0xbf350507,2
+np.float32,0xc2395a9e,0xbf350507,2
+np.float32,0x42b95a9e,0x36651267,2
+np.float32,0xc2b95a9e,0x36651267,2
+np.float32,0x43395a9e,0xbf800000,2
+np.float32,0xc3395a9e,0xbf800000,2
+np.float32,0x423c7edd,0xbf800000,2
+np.float32,0xc23c7edd,0xbf800000,2
+np.float32,0x42bc7edd,0x3f800000,2
+np.float32,0xc2bc7edd,0x3f800000,2
+np.float32,0x433c7edd,0x3f800000,2
+np.float32,0xc33c7edd,0x3f800000,2
+np.float32,0x423fa31d,0xbf3504d7,2
+np.float32,0xc23fa31d,0xbf3504d7,2
+np.float32,0x42bfa31d,0xb69d7828,2
+np.float32,0xc2bfa31d,0xb69d7828,2
+np.float32,0x433fa31d,0xbf800000,2
+np.float32,0xc33fa31d,0xbf800000,2
+np.float32,0x4242c75c,0x354bbe8a,2
+np.float32,0xc242c75c,0x354bbe8a,2
+np.float32,0x42c2c75c,0xbf800000,2
+np.float32,0xc2c2c75c,0xbf800000,2
+np.float32,0x4342c75c,0x3f800000,2
+np.float32,0xc342c75c,0x3f800000,2
+np.float32,0x4245eb9c,0x3f350517,2
+np.float32,0xc245eb9c,0x3f350517,2
+np.float32,0x42c5eb9c,0x36c8671d,2
+np.float32,0xc2c5eb9c,0x36c8671d,2
+np.float32,0x4345eb9c,0xbf800000,2
+np.float32,0xc345eb9c,0xbf800000,2
+np.float32,0x42490fdb,0x3f800000,2
+np.float32,0xc2490fdb,0x3f800000,2
+np.float32,0x42c90fdb,0x3f800000,2
+np.float32,0xc2c90fdb,0x3f800000,2
+np.float32,0x43490fdb,0x3f800000,2
+np.float32,0xc3490fdb,0x3f800000,2
+np.float32,0x424c341a,0x3f3504f5,2
+np.float32,0xc24c341a,0x3f3504f5,2
+np.float32,0x42cc341a,0x34ca9ee6,2
+np.float32,0xc2cc341a,0x34ca9ee6,2
+np.float32,0x434c341a,0xbf800000,2
+np.float32,0xc34c341a,0xbf800000,2
+np.float32,0x424f585a,0xb608cd8c,2
+np.float32,0xc24f585a,0xb608cd8c,2
+np.float32,0x42cf585a,0xbf800000,2
+np.float32,0xc2cf585a,0xbf800000,2
+np.float32,0x434f585a,0x3f800000,2
+np.float32,0xc34f585a,0x3f800000,2
+np.float32,0x42527c99,0xbf3504f9,2
+np.float32,0xc2527c99,0xbf3504f9,2
+np.float32,0x42d27c99,0x35722833,2
+np.float32,0xc2d27c99,0x35722833,2
+np.float32,0x43527c99,0xbf800000,2
+np.float32,0xc3527c99,0xbf800000,2
+np.float32,0x4255a0d9,0xbf800000,2
+np.float32,0xc255a0d9,0xbf800000,2
+np.float32,0x42d5a0d9,0x3f800000,2
+np.float32,0xc2d5a0d9,0x3f800000,2
+np.float32,0x4355a0d9,0x3f800000,2
+np.float32,0xc355a0d9,0x3f800000,2
+np.float32,0x4258c518,0xbf3504e6,2
+np.float32,0xc258c518,0xbf3504e6,2
+np.float32,0x42d8c518,0xb61267f6,2
+np.float32,0xc2d8c518,0xb61267f6,2
+np.float32,0x4358c518,0xbf800000,2
+np.float32,0xc358c518,0xbf800000,2
+np.float32,0x425be958,0x365eab75,2
+np.float32,0xc25be958,0x365eab75,2
+np.float32,0x42dbe958,0xbf800000,2
+np.float32,0xc2dbe958,0xbf800000,2
+np.float32,0x435be958,0x3f800000,2
+np.float32,0xc35be958,0x3f800000,2
+np.float32,0x425f0d97,0x3f350508,2
+np.float32,0xc25f0d97,0x3f350508,2
+np.float32,0x42df0d97,0x366845e0,2
+np.float32,0xc2df0d97,0x366845e0,2
+np.float32,0x435f0d97,0xbf800000,2
+np.float32,0xc35f0d97,0xbf800000,2
+np.float32,0x426231d6,0x3f800000,2
+np.float32,0xc26231d6,0x3f800000,2
+np.float32,0x42e231d6,0x3f800000,2
+np.float32,0xc2e231d6,0x3f800000,2
+np.float32,0x436231d6,0x3f800000,2
+np.float32,0xc36231d6,0x3f800000,2
+np.float32,0x42655616,0x3f3504d7,2
+np.float32,0xc2655616,0x3f3504d7,2
+np.float32,0x42e55616,0xb69f11e5,2
+np.float32,0xc2e55616,0xb69f11e5,2
+np.float32,0x43655616,0xbf800000,2
+np.float32,0xc3655616,0xbf800000,2
+np.float32,0x42687a55,0xb552257b,2
+np.float32,0xc2687a55,0xb552257b,2
+np.float32,0x42e87a55,0xbf800000,2
+np.float32,0xc2e87a55,0xbf800000,2
+np.float32,0x43687a55,0x3f800000,2
+np.float32,0xc3687a55,0x3f800000,2
+np.float32,0x426b9e95,0xbf350517,2
+np.float32,0xc26b9e95,0xbf350517,2
+np.float32,0x42eb9e95,0x36ca00d9,2
+np.float32,0xc2eb9e95,0x36ca00d9,2
+np.float32,0x436b9e95,0xbf800000,2
+np.float32,0xc36b9e95,0xbf800000,2
+np.float32,0x426ec2d4,0xbf800000,2
+np.float32,0xc26ec2d4,0xbf800000,2
+np.float32,0x42eec2d4,0x3f800000,2
+np.float32,0xc2eec2d4,0x3f800000,2
+np.float32,0x436ec2d4,0x3f800000,2
+np.float32,0xc36ec2d4,0x3f800000,2
+np.float32,0x4271e713,0xbf3504f5,2
+np.float32,0xc271e713,0xbf3504f5,2
+np.float32,0x42f1e713,0x34b10321,2
+np.float32,0xc2f1e713,0x34b10321,2
+np.float32,0x4371e713,0xbf800000,2
+np.float32,0xc371e713,0xbf800000,2
+np.float32,0x42750b53,0x360a6748,2
+np.float32,0xc2750b53,0x360a6748,2
+np.float32,0x42f50b53,0xbf800000,2
+np.float32,0xc2f50b53,0xbf800000,2
+np.float32,0x43750b53,0x3f800000,2
+np.float32,0xc3750b53,0x3f800000,2
+np.float32,0x42782f92,0x3f3504f9,2
+np.float32,0xc2782f92,0x3f3504f9,2
+np.float32,0x42f82f92,0x357ef616,2
+np.float32,0xc2f82f92,0x357ef616,2
+np.float32,0x43782f92,0xbf800000,2
+np.float32,0xc3782f92,0xbf800000,2
+np.float32,0x427b53d2,0x3f800000,2
+np.float32,0xc27b53d2,0x3f800000,2
+np.float32,0x42fb53d2,0x3f800000,2
+np.float32,0xc2fb53d2,0x3f800000,2
+np.float32,0x437b53d2,0x3f800000,2
+np.float32,0xc37b53d2,0x3f800000,2
+np.float32,0x427e7811,0x3f3504e6,2
+np.float32,0xc27e7811,0x3f3504e6,2
+np.float32,0x42fe7811,0xb6159b6f,2
+np.float32,0xc2fe7811,0xb6159b6f,2
+np.float32,0x437e7811,0xbf800000,2
+np.float32,0xc37e7811,0xbf800000,2
+np.float32,0x4280ce28,0x34fdd672,2
+np.float32,0xc280ce28,0x34fdd672,2
+np.float32,0x4300ce28,0xbf800000,2
+np.float32,0xc300ce28,0xbf800000,2
+np.float32,0x4380ce28,0x3f800000,2
+np.float32,0xc380ce28,0x3f800000,2
+np.float32,0x42826048,0xbf350508,2
+np.float32,0xc2826048,0xbf350508,2
+np.float32,0x43026048,0x366b7958,2
+np.float32,0xc3026048,0x366b7958,2
+np.float32,0x43826048,0xbf800000,2
+np.float32,0xc3826048,0xbf800000,2
+np.float32,0x4283f268,0xbf800000,2
+np.float32,0xc283f268,0xbf800000,2
+np.float32,0x4303f268,0x3f800000,2
+np.float32,0xc303f268,0x3f800000,2
+np.float32,0x4383f268,0x3f800000,2
+np.float32,0xc383f268,0x3f800000,2
+np.float32,0x42858487,0xbf350504,2
+np.float32,0xc2858487,0xbf350504,2
+np.float32,0x43058487,0x363ea8be,2
+np.float32,0xc3058487,0x363ea8be,2
+np.float32,0x43858487,0xbf800000,2
+np.float32,0xc3858487,0xbf800000,2
+np.float32,0x428716a7,0x35588c6d,2
+np.float32,0xc28716a7,0x35588c6d,2
+np.float32,0x430716a7,0xbf800000,2
+np.float32,0xc30716a7,0xbf800000,2
+np.float32,0x438716a7,0x3f800000,2
+np.float32,0xc38716a7,0x3f800000,2
+np.float32,0x4288a8c7,0x3f350517,2
+np.float32,0xc288a8c7,0x3f350517,2
+np.float32,0x4308a8c7,0x36cb9a96,2
+np.float32,0xc308a8c7,0x36cb9a96,2
+np.float32,0x4388a8c7,0xbf800000,2
+np.float32,0xc388a8c7,0xbf800000,2
+np.float32,0x428a3ae7,0x3f800000,2
+np.float32,0xc28a3ae7,0x3f800000,2
+np.float32,0x430a3ae7,0x3f800000,2
+np.float32,0xc30a3ae7,0x3f800000,2
+np.float32,0x438a3ae7,0x3f800000,2
+np.float32,0xc38a3ae7,0x3f800000,2
+np.float32,0x428bcd06,0x3f3504f5,2
+np.float32,0xc28bcd06,0x3f3504f5,2
+np.float32,0x430bcd06,0x3497675b,2
+np.float32,0xc30bcd06,0x3497675b,2
+np.float32,0x438bcd06,0xbf800000,2
+np.float32,0xc38bcd06,0xbf800000,2
+np.float32,0x428d5f26,0xb60c0105,2
+np.float32,0xc28d5f26,0xb60c0105,2
+np.float32,0x430d5f26,0xbf800000,2
+np.float32,0xc30d5f26,0xbf800000,2
+np.float32,0x438d5f26,0x3f800000,2
+np.float32,0xc38d5f26,0x3f800000,2
+np.float32,0x428ef146,0xbf350526,2
+np.float32,0xc28ef146,0xbf350526,2
+np.float32,0x430ef146,0x3710bc40,2
+np.float32,0xc30ef146,0x3710bc40,2
+np.float32,0x438ef146,0xbf800000,2
+np.float32,0xc38ef146,0xbf800000,2
+np.float32,0x42908365,0xbf800000,2
+np.float32,0xc2908365,0xbf800000,2
+np.float32,0x43108365,0x3f800000,2
+np.float32,0xc3108365,0x3f800000,2
+np.float32,0x43908365,0x3f800000,2
+np.float32,0xc3908365,0x3f800000,2
+np.float32,0x42921585,0xbf3504e6,2
+np.float32,0xc2921585,0xbf3504e6,2
+np.float32,0x43121585,0xb618cee8,2
+np.float32,0xc3121585,0xb618cee8,2
+np.float32,0x43921585,0xbf800000,2
+np.float32,0xc3921585,0xbf800000,2
+np.float32,0x4293a7a5,0x3661deee,2
+np.float32,0xc293a7a5,0x3661deee,2
+np.float32,0x4313a7a5,0xbf800000,2
+np.float32,0xc313a7a5,0xbf800000,2
+np.float32,0x4393a7a5,0x3f800000,2
+np.float32,0xc393a7a5,0x3f800000,2
+np.float32,0x429539c5,0x3f350536,2
+np.float32,0xc29539c5,0x3f350536,2
+np.float32,0x431539c5,0x373bab34,2
+np.float32,0xc31539c5,0x373bab34,2
+np.float32,0x439539c5,0xbf800000,2
+np.float32,0xc39539c5,0xbf800000,2
+np.float32,0x4296cbe4,0x3f800000,2
+np.float32,0xc296cbe4,0x3f800000,2
+np.float32,0x4316cbe4,0x3f800000,2
+np.float32,0xc316cbe4,0x3f800000,2
+np.float32,0x4396cbe4,0x3f800000,2
+np.float32,0xc396cbe4,0x3f800000,2
+np.float32,0x42985e04,0x3f3504d7,2
+np.float32,0xc2985e04,0x3f3504d7,2
+np.float32,0x43185e04,0xb6a2455d,2
+np.float32,0xc3185e04,0xb6a2455d,2
+np.float32,0x43985e04,0xbf800000,2
+np.float32,0xc3985e04,0xbf800000,2
+np.float32,0x4299f024,0xb69bde6c,2
+np.float32,0xc299f024,0xb69bde6c,2
+np.float32,0x4319f024,0xbf800000,2
+np.float32,0xc319f024,0xbf800000,2
+np.float32,0x4399f024,0x3f800000,2
+np.float32,0xc399f024,0x3f800000,2
+np.float32,0x429b8243,0xbf3504ea,2
+np.float32,0xc29b8243,0xbf3504ea,2
+np.float32,0x431b8243,0xb5cb2eb8,2
+np.float32,0xc31b8243,0xb5cb2eb8,2
+np.float32,0x439b8243,0xbf800000,2
+np.float32,0xc39b8243,0xbf800000,2
+np.float32,0x435b2047,0x3f3504c1,2
+np.float32,0x42a038a2,0xb5e4ca7e,2
+np.float32,0x432038a2,0xbf800000,2
+np.float32,0x4345eb9b,0xbf800000,2
+np.float32,0x42c5eb9b,0xb5de638c,2
+np.float32,0x42eb9e94,0xb5d7fc9b,2
+np.float32,0x4350ea79,0x3631dadb,2
+np.float32,0x42dbe957,0xbf800000,2
+np.float32,0x425be957,0xb505522a,2
+np.float32,0x435be957,0x3f800000,2
+np.float32,0x46027eb2,0x3e7d94c9,2
+np.float32,0x4477baed,0xbe7f1824,2
+np.float32,0x454b8024,0x3e7f5268,2
+np.float32,0x455d2c09,0x3e7f40cb,2
+np.float32,0x4768d3de,0xba14b4af,2
+np.float32,0x46c1e7cd,0x3e7fb102,2
+np.float32,0x44a52949,0xbe7dc9d5,2
+np.float32,0x4454633a,0x3e7dbc7d,2
+np.float32,0x4689810b,0x3e7eb02b,2
+np.float32,0x473473cd,0xbe7eef6f,2
+np.float32,0x44a5193f,0x3e7e1b1f,2
+np.float32,0x46004b36,0x3e7dac59,2
+np.float32,0x467f604b,0x3d7ffd3a,2
+np.float32,0x45ea1805,0x3dffd2e0,2
+np.float32,0x457b6af3,0x3dff7831,2
+np.float32,0x44996159,0xbe7d85f4,2
+np.float32,0x47883553,0xbb80584e,2
+np.float32,0x44e19f0c,0xbdffcfe6,2
+np.float32,0x472b3bf6,0xbe7f7a82,2
+np.float32,0x4600bb4e,0x3a135e33,2
+np.float32,0x449f4556,0x3e7e42e5,2
+np.float32,0x474e9420,0x3dff77b2,2
+np.float32,0x45cbdb23,0x3dff7240,2
+np.float32,0x44222747,0x3dffb039,2
+np.float32,0x4772e419,0xbdff74b8,2
+np.float64,0x1,0x3ff0000000000000,1
+np.float64,0x8000000000000001,0x3ff0000000000000,1
+np.float64,0x10000000000000,0x3ff0000000000000,1
+np.float64,0x8010000000000000,0x3ff0000000000000,1
+np.float64,0x7fefffffffffffff,0xbfefffe62ecfab75,1
+np.float64,0xffefffffffffffff,0xbfefffe62ecfab75,1
+np.float64,0x7ff0000000000000,0xfff8000000000000,1
+np.float64,0xfff0000000000000,0xfff8000000000000,1
+np.float64,0x7ff8000000000000,0x7ff8000000000000,1
+np.float64,0x7ff4000000000000,0x7ffc000000000000,1
+np.float64,0xbfc28bd9dd2517b4,0x3fefaa28ba13a702,1
+np.float64,0x3fb673c62e2ce790,0x3fefe083847a717f,1
+np.float64,0xbfe3e1dac7e7c3b6,0x3fea0500ba099f3a,1
+np.float64,0xbfbe462caa3c8c58,0x3fefc6c8b9c1c87c,1
+np.float64,0xbfb9353576326a68,0x3fefd8513e50e6b1,1
+np.float64,0xbfc05e798520bcf4,0x3fefbd1ad81cf089,1
+np.float64,0xbfe3ca3be2e79478,0x3fea12b995ea6574,1
+np.float64,0xbfde875d46bd0eba,0x3fec6d888662a824,1
+np.float64,0x3fafc4e02c3f89c0,0x3feff03c34bffd69,1
+np.float64,0xbf98855848310ac0,0x3feffda6c1588bdb,1
+np.float64,0x3fe66c51186cd8a2,0x3fe875c61c630ecb,1
+np.float64,0xbfedff1c3b7bfe38,0x3fe2f0c8c9e8fa39,1
+np.float64,0x3fd6082267ac1044,0x3fee1f6023695050,1
+np.float64,0xbfe78449b06f0894,0x3fe7bda2b223850e,1
+np.float64,0x3feedb8e63fdb71c,0x3fe23d5dfd2dd33f,1
+np.float64,0xbfc0a9de3d2153bc,0x3fefbaadf5e5285e,1
+np.float64,0x3fc04c67432098d0,0x3fefbdae07b7de8d,1
+np.float64,0xbfeeef84c4fddf0a,0x3fe22cf37f309d88,1
+np.float64,0x3fc04bb025209760,0x3fefbdb3d7d34ecf,1
+np.float64,0x3fd6b84d48ad709c,0x3fee013403da6e2a,1
+np.float64,0x3fec1ae25d7835c4,0x3fe46e62195cf274,1
+np.float64,0xbfdc6fdf9bb8dfc0,0x3fece48dc78bbb2e,1
+np.float64,0x3fb4db2c9229b660,0x3fefe4d42f79bf49,1
+np.float64,0xbfc0ed698521dad4,0x3fefb8785ea658c9,1
+np.float64,0xbfee82772b7d04ee,0x3fe2864a80efe8e9,1
+np.float64,0x3fd575b664aaeb6c,0x3fee37c669a12879,1
+np.float64,0x3fe4afb1c5e95f64,0x3fe98b177194439c,1
+np.float64,0x3fd93962f9b272c4,0x3fed8bef61876294,1
+np.float64,0x3fd97ae025b2f5c0,0x3fed7f4cfbf4d300,1
+np.float64,0xbfd9afdb1bb35fb6,0x3fed74fdc44dabb1,1
+np.float64,0x3f8ae65e3035cc80,0x3fefff4b1a0ea62b,1
+np.float64,0xbfe7e58664efcb0d,0x3fe77c02a1cbb670,1
+np.float64,0x3fe5f68b37ebed16,0x3fe8c10f849a5d4d,1
+np.float64,0x3fd9137d61b226fc,0x3fed9330eb4815a1,1
+np.float64,0x3fc146d019228da0,0x3fefb57e2d4d52f8,1
+np.float64,0xbfda6036edb4c06e,0x3fed521b2b578679,1
+np.float64,0xbfe78ddfb0ef1bc0,0x3fe7b734319a77e4,1
+np.float64,0x3fe0877823610ef0,0x3febd33a993dd786,1
+np.float64,0x3fbc61af2e38c360,0x3fefcdb4f889756d,1
+np.float64,0x3fd4dcdca4a9b9b8,0x3fee50962ffea5ae,1
+np.float64,0xbfe03cb29f607965,0x3febf7dbf640a75a,1
+np.float64,0xbfc81de407303bc8,0x3fef6f066cef64bc,1
+np.float64,0x3fd8dea42db1bd48,0x3fed9d3e00dbe0b3,1
+np.float64,0x3feac75e94f58ebe,0x3fe56f1f47f97896,1
+np.float64,0x3fb3a1ea6e2743d0,0x3fefe7ec1247cdaa,1
+np.float64,0x3fd695c0f4ad2b80,0x3fee0730bd40883d,1
+np.float64,0xbfd2c631f5a58c64,0x3feea20cbd1105d7,1
+np.float64,0xbfe978a8e1f2f152,0x3fe663014d40ad7a,1
+np.float64,0x3fd8b6b76ab16d70,0x3feda4c879aacc19,1
+np.float64,0x3feaafd30e755fa6,0x3fe5809514c28453,1
+np.float64,0x3fe1e37dc263c6fc,0x3feb20f9ad1f3f5c,1
+np.float64,0x3fd0ec7c24a1d8f8,0x3feee34048f43b75,1
+np.float64,0xbfe3881cbf67103a,0x3fea38d7886e6f53,1
+np.float64,0xbfd7023957ae0472,0x3fedf4471c765a1c,1
+np.float64,0xbfebc51c4ef78a38,0x3fe4b01c424e297b,1
+np.float64,0xbfe20a93eae41528,0x3feb0c2aa321d2e0,1
+np.float64,0x3fef39be867e737e,0x3fe1efaba9164d27,1
+np.float64,0x3fe8ea9576f1d52a,0x3fe6c7a8826ce1be,1
+np.float64,0x3fea921d91f5243c,0x3fe5968c6cf78963,1
+np.float64,0x3fd7ee5d31afdcbc,0x3fedc9f19d43fe61,1
+np.float64,0xbfe3ed581767dab0,0x3fe9fe4ee2f2b1cd,1
+np.float64,0xbfc40923d5281248,0x3fef9bd8ee9f6e68,1
+np.float64,0x3fe411a834682350,0x3fe9e9103854f057,1
+np.float64,0xbfedf6ccdf7bed9a,0x3fe2f77ad6543246,1
+np.float64,0xbfe8788a44f0f114,0x3fe7172f3aa0c742,1
+np.float64,0xbfce728f173ce520,0x3fef1954083bea04,1
+np.float64,0xbfd64dd0acac9ba2,0x3fee138c3293c246,1
+np.float64,0xbfe00669f5600cd4,0x3fec121443945350,1
+np.float64,0xbfe7152ba2ee2a58,0x3fe8079465d09846,1
+np.float64,0x3fe8654d8f70ca9c,0x3fe7247c94f09596,1
+np.float64,0x3fea68045cf4d008,0x3fe5b58cfe81a243,1
+np.float64,0xbfcd4779073a8ef4,0x3fef2a9d78153fa5,1
+np.float64,0xbfdb4456e5b688ae,0x3fed23b11614203f,1
+np.float64,0x3fcb5d59cd36bab0,0x3fef45818216a515,1
+np.float64,0xbfd914ff5ab229fe,0x3fed92e73746fea8,1
+np.float64,0x3fe4d211db69a424,0x3fe97653f433d15f,1
+np.float64,0xbfdbbb9224b77724,0x3fed0adb593dde80,1
+np.float64,0x3fd424ceafa8499c,0x3fee6d9124795d33,1
+np.float64,0x3feb5968f976b2d2,0x3fe501d116efbf54,1
+np.float64,0x3fee7d92a2fcfb26,0x3fe28a479b6a9dcf,1
+np.float64,0x3fc308e9972611d0,0x3fefa595f4df0c89,1
+np.float64,0x3fda79cd77b4f39c,0x3fed4cf8e69ba1f8,1
+np.float64,0x3fcbcf42d5379e88,0x3fef3f6a6a77c187,1
+np.float64,0x3fe13a1da662743c,0x3feb79504faea888,1
+np.float64,0xbfee4435f07c886c,0x3fe2b8ea98d2fc29,1
+np.float64,0x3fd65d68ccacbad0,0x3fee10e1ac7ada89,1
+np.float64,0x3fef2f89bb7e5f14,0x3fe1f81e882cc3f4,1
+np.float64,0xbfef0a7769fe14ef,0x3fe216bf384fc646,1
+np.float64,0x3fc065277320ca50,0x3fefbce44835c193,1
+np.float64,0x3fe9c1a74d73834e,0x3fe62e9ee0c2f2bf,1
+np.float64,0x3fd9d96e5db3b2dc,0x3fed6cd88eb51f6a,1
+np.float64,0x3fe02bf1c56057e4,0x3febfffc24b5a7ba,1
+np.float64,0xbfd6814350ad0286,0x3fee0ab9ad318b84,1
+np.float64,0x3f9fcbec583f97c0,0x3feffc0d0f1d8e75,1
+np.float64,0x3fe23524e5e46a4a,0x3feaf55372949a06,1
+np.float64,0xbfbdc95f6a3b92c0,0x3fefc89c21d44995,1
+np.float64,0x3fe961bb9cf2c378,0x3fe6735d6e1cca58,1
+np.float64,0xbfe8f1c370f1e387,0x3fe6c29d1be8bee9,1
+np.float64,0x3fd880d43ab101a8,0x3fedaee3c7ccfc96,1
+np.float64,0xbfedb37005fb66e0,0x3fe32d91ef2e3bd3,1
+np.float64,0xfdce287bfb9c5,0x3ff0000000000000,1
+np.float64,0x9aa1b9e735437,0x3ff0000000000000,1
+np.float64,0x6beac6e0d7d59,0x3ff0000000000000,1
+np.float64,0x47457aae8e8b0,0x3ff0000000000000,1
+np.float64,0x35ff13b46bfe3,0x3ff0000000000000,1
+np.float64,0xb9c0c82b73819,0x3ff0000000000000,1
+np.float64,0x1a8dc21a351b9,0x3ff0000000000000,1
+np.float64,0x7e87ef6afd0ff,0x3ff0000000000000,1
+np.float64,0x620a6588c414d,0x3ff0000000000000,1
+np.float64,0x7f366000fe6e,0x3ff0000000000000,1
+np.float64,0x787e39f4f0fc8,0x3ff0000000000000,1
+np.float64,0xf5134f1fea26a,0x3ff0000000000000,1
+np.float64,0xbce700ef79ce0,0x3ff0000000000000,1
+np.float64,0x144d7cc8289b1,0x3ff0000000000000,1
+np.float64,0xb9fbc5b973f79,0x3ff0000000000000,1
+np.float64,0xc3d6292d87ac5,0x3ff0000000000000,1
+np.float64,0xc1084e618210a,0x3ff0000000000000,1
+np.float64,0xb6b9eca56d73e,0x3ff0000000000000,1
+np.float64,0xc7ac4b858f58a,0x3ff0000000000000,1
+np.float64,0x516d75d2a2daf,0x3ff0000000000000,1
+np.float64,0x9dc089d93b811,0x3ff0000000000000,1
+np.float64,0x7b5f2840f6be6,0x3ff0000000000000,1
+np.float64,0x121d3ce8243a9,0x3ff0000000000000,1
+np.float64,0xf0be0337e17c1,0x3ff0000000000000,1
+np.float64,0xff58a5cbfeb15,0x3ff0000000000000,1
+np.float64,0xdaf1d07fb5e3a,0x3ff0000000000000,1
+np.float64,0x61d95382c3b2b,0x3ff0000000000000,1
+np.float64,0xe4df943fc9bf3,0x3ff0000000000000,1
+np.float64,0xf72ac2bdee559,0x3ff0000000000000,1
+np.float64,0x12dafbf625b60,0x3ff0000000000000,1
+np.float64,0xee11d427dc23b,0x3ff0000000000000,1
+np.float64,0xf4f8eb37e9f1e,0x3ff0000000000000,1
+np.float64,0xad7cb5df5af97,0x3ff0000000000000,1
+np.float64,0x59fc9b06b3f94,0x3ff0000000000000,1
+np.float64,0x3c3e65e4787ce,0x3ff0000000000000,1
+np.float64,0xe37bc993c6f79,0x3ff0000000000000,1
+np.float64,0x13bd6330277ad,0x3ff0000000000000,1
+np.float64,0x56cc2800ad986,0x3ff0000000000000,1
+np.float64,0x6203b8fcc4078,0x3ff0000000000000,1
+np.float64,0x75c7c8b8eb8fa,0x3ff0000000000000,1
+np.float64,0x5ebf8e00bd7f2,0x3ff0000000000000,1
+np.float64,0xda81f2f1b503f,0x3ff0000000000000,1
+np.float64,0x6adb17d6d5b64,0x3ff0000000000000,1
+np.float64,0x1ba68eee374d3,0x3ff0000000000000,1
+np.float64,0xeecf6fbbdd9ee,0x3ff0000000000000,1
+np.float64,0x24d6dd8e49add,0x3ff0000000000000,1
+np.float64,0xdf7cb81bbef97,0x3ff0000000000000,1
+np.float64,0xafd7be1b5faf8,0x3ff0000000000000,1
+np.float64,0xdb90ca35b721a,0x3ff0000000000000,1
+np.float64,0xa72903a14e521,0x3ff0000000000000,1
+np.float64,0x14533ee028a7,0x3ff0000000000000,1
+np.float64,0x7951540cf2a2b,0x3ff0000000000000,1
+np.float64,0x22882be045106,0x3ff0000000000000,1
+np.float64,0x136270d626c4f,0x3ff0000000000000,1
+np.float64,0x6a0f5744d41ec,0x3ff0000000000000,1
+np.float64,0x21e0d1aa43c1b,0x3ff0000000000000,1
+np.float64,0xee544155dca88,0x3ff0000000000000,1
+np.float64,0xcbe8aac797d16,0x3ff0000000000000,1
+np.float64,0x6c065e80d80e,0x3ff0000000000000,1
+np.float64,0xe57f0411cafe1,0x3ff0000000000000,1
+np.float64,0xdec3a6bdbd875,0x3ff0000000000000,1
+np.float64,0xf4d23a0fe9a48,0x3ff0000000000000,1
+np.float64,0xda77ef47b4efe,0x3ff0000000000000,1
+np.float64,0x8c405c9b1880c,0x3ff0000000000000,1
+np.float64,0x4eced5149d9db,0x3ff0000000000000,1
+np.float64,0x16b6552c2d6cc,0x3ff0000000000000,1
+np.float64,0x6fbc262cdf785,0x3ff0000000000000,1
+np.float64,0x628c3844c5188,0x3ff0000000000000,1
+np.float64,0x6d827d2cdb050,0x3ff0000000000000,1
+np.float64,0xd1bfdf29a37fc,0x3ff0000000000000,1
+np.float64,0xd85400fdb0a80,0x3ff0000000000000,1
+np.float64,0xcc420b2d98842,0x3ff0000000000000,1
+np.float64,0xac41d21b5883b,0x3ff0000000000000,1
+np.float64,0x432f18d4865e4,0x3ff0000000000000,1
+np.float64,0xe7e89a1bcfd14,0x3ff0000000000000,1
+np.float64,0x9b1141d536228,0x3ff0000000000000,1
+np.float64,0x6805f662d00bf,0x3ff0000000000000,1
+np.float64,0xc76552358ecab,0x3ff0000000000000,1
+np.float64,0x4ae8ffee95d21,0x3ff0000000000000,1
+np.float64,0x4396c096872d9,0x3ff0000000000000,1
+np.float64,0x6e8e55d4dd1cb,0x3ff0000000000000,1
+np.float64,0x4c2e33dc985c7,0x3ff0000000000000,1
+np.float64,0xbce814a579d03,0x3ff0000000000000,1
+np.float64,0x911681b5222d0,0x3ff0000000000000,1
+np.float64,0x5f90a4b2bf215,0x3ff0000000000000,1
+np.float64,0x26f76be84deee,0x3ff0000000000000,1
+np.float64,0xb2f7536165eeb,0x3ff0000000000000,1
+np.float64,0x4de4e6089bc9d,0x3ff0000000000000,1
+np.float64,0xf2e016afe5c03,0x3ff0000000000000,1
+np.float64,0xb9b7b949736f7,0x3ff0000000000000,1
+np.float64,0x3363ea1866c7e,0x3ff0000000000000,1
+np.float64,0xd1a3bd6ba3478,0x3ff0000000000000,1
+np.float64,0xae89f3595d13f,0x3ff0000000000000,1
+np.float64,0xddbd9601bb7c,0x3ff0000000000000,1
+np.float64,0x5de41a06bbc84,0x3ff0000000000000,1
+np.float64,0xfd58c86dfab19,0x3ff0000000000000,1
+np.float64,0x24922e8c49247,0x3ff0000000000000,1
+np.float64,0xcda040339b408,0x3ff0000000000000,1
+np.float64,0x5fe500b2bfca1,0x3ff0000000000000,1
+np.float64,0x9214abb924296,0x3ff0000000000000,1
+np.float64,0x800609fe0a2c13fd,0x3ff0000000000000,1
+np.float64,0x800c7c6fe518f8e0,0x3ff0000000000000,1
+np.float64,0x800a1a9491b4352a,0x3ff0000000000000,1
+np.float64,0x800b45e0e8968bc2,0x3ff0000000000000,1
+np.float64,0x8008497e57d092fd,0x3ff0000000000000,1
+np.float64,0x800b9c0af0173816,0x3ff0000000000000,1
+np.float64,0x800194cccb43299a,0x3ff0000000000000,1
+np.float64,0x8001c91ef183923f,0x3ff0000000000000,1
+np.float64,0x800f25b5ccde4b6c,0x3ff0000000000000,1
+np.float64,0x800ce63ccc79cc7a,0x3ff0000000000000,1
+np.float64,0x800d8fb2e83b1f66,0x3ff0000000000000,1
+np.float64,0x80083cd06f7079a1,0x3ff0000000000000,1
+np.float64,0x800823598e9046b3,0x3ff0000000000000,1
+np.float64,0x8001c1319de38264,0x3ff0000000000000,1
+np.float64,0x800f2b68543e56d1,0x3ff0000000000000,1
+np.float64,0x80022a4f4364549f,0x3ff0000000000000,1
+np.float64,0x800f51badf7ea376,0x3ff0000000000000,1
+np.float64,0x8003fbf31e27f7e7,0x3ff0000000000000,1
+np.float64,0x800d4c00e2fa9802,0x3ff0000000000000,1
+np.float64,0x800023b974804774,0x3ff0000000000000,1
+np.float64,0x800860778990c0ef,0x3ff0000000000000,1
+np.float64,0x800a15c241542b85,0x3ff0000000000000,1
+np.float64,0x8003097d9dc612fc,0x3ff0000000000000,1
+np.float64,0x800d77d8541aefb1,0x3ff0000000000000,1
+np.float64,0x80093804ab52700a,0x3ff0000000000000,1
+np.float64,0x800d2b3bfd7a5678,0x3ff0000000000000,1
+np.float64,0x800da24bcd5b4498,0x3ff0000000000000,1
+np.float64,0x8006eee1c28dddc4,0x3ff0000000000000,1
+np.float64,0x80005137fa40a271,0x3ff0000000000000,1
+np.float64,0x8007a3fbc22f47f8,0x3ff0000000000000,1
+np.float64,0x800dcd97071b9b2e,0x3ff0000000000000,1
+np.float64,0x80065b36048cb66d,0x3ff0000000000000,1
+np.float64,0x8004206ba72840d8,0x3ff0000000000000,1
+np.float64,0x8007e82b98cfd058,0x3ff0000000000000,1
+np.float64,0x8001a116ed23422f,0x3ff0000000000000,1
+np.float64,0x800c69e9ff18d3d4,0x3ff0000000000000,1
+np.float64,0x8003843688e7086e,0x3ff0000000000000,1
+np.float64,0x800335e3b8866bc8,0x3ff0000000000000,1
+np.float64,0x800e3308f0bc6612,0x3ff0000000000000,1
+np.float64,0x8002a9ec55c553d9,0x3ff0000000000000,1
+np.float64,0x80001c2084e03842,0x3ff0000000000000,1
+np.float64,0x800bc2bbd8d78578,0x3ff0000000000000,1
+np.float64,0x800ae6bcc555cd7a,0x3ff0000000000000,1
+np.float64,0x80083f7a13907ef5,0x3ff0000000000000,1
+np.float64,0x800d83ed76db07db,0x3ff0000000000000,1
+np.float64,0x800a12251974244b,0x3ff0000000000000,1
+np.float64,0x800a69c95714d393,0x3ff0000000000000,1
+np.float64,0x800cd5a85639ab51,0x3ff0000000000000,1
+np.float64,0x800e0e1837bc1c31,0x3ff0000000000000,1
+np.float64,0x8007b5ca39ef6b95,0x3ff0000000000000,1
+np.float64,0x800cf961cad9f2c4,0x3ff0000000000000,1
+np.float64,0x80066e8fc14cdd20,0x3ff0000000000000,1
+np.float64,0x8001cb8c7b43971a,0x3ff0000000000000,1
+np.float64,0x800002df68a005c0,0x3ff0000000000000,1
+np.float64,0x8003e6681567ccd1,0x3ff0000000000000,1
+np.float64,0x800b039126b60723,0x3ff0000000000000,1
+np.float64,0x800d2e1b663a5c37,0x3ff0000000000000,1
+np.float64,0x800188b3e2a31169,0x3ff0000000000000,1
+np.float64,0x8001f272e943e4e7,0x3ff0000000000000,1
+np.float64,0x800d7f53607afea7,0x3ff0000000000000,1
+np.float64,0x80092cafa4f25960,0x3ff0000000000000,1
+np.float64,0x800fc009f07f8014,0x3ff0000000000000,1
+np.float64,0x8003da896507b514,0x3ff0000000000000,1
+np.float64,0x800d4d1b4c3a9a37,0x3ff0000000000000,1
+np.float64,0x8007a835894f506c,0x3ff0000000000000,1
+np.float64,0x80057ba0522af741,0x3ff0000000000000,1
+np.float64,0x8009b7054b336e0b,0x3ff0000000000000,1
+np.float64,0x800b2c6c125658d9,0x3ff0000000000000,1
+np.float64,0x8008b1840ad16308,0x3ff0000000000000,1
+np.float64,0x8007ea0e3befd41d,0x3ff0000000000000,1
+np.float64,0x800dd658683bacb1,0x3ff0000000000000,1
+np.float64,0x8008cda48fd19b49,0x3ff0000000000000,1
+np.float64,0x8003acca14c75995,0x3ff0000000000000,1
+np.float64,0x8008bd152d717a2b,0x3ff0000000000000,1
+np.float64,0x80010d1ea3621a3e,0x3ff0000000000000,1
+np.float64,0x800130b78b826170,0x3ff0000000000000,1
+np.float64,0x8002cf3a46e59e75,0x3ff0000000000000,1
+np.float64,0x800b76e7fa76edd0,0x3ff0000000000000,1
+np.float64,0x800e065fe1dc0cc0,0x3ff0000000000000,1
+np.float64,0x8000dd527ea1baa6,0x3ff0000000000000,1
+np.float64,0x80032cb234665965,0x3ff0000000000000,1
+np.float64,0x800affc1acb5ff84,0x3ff0000000000000,1
+np.float64,0x80074be23fee97c5,0x3ff0000000000000,1
+np.float64,0x8004f83eafc9f07e,0x3ff0000000000000,1
+np.float64,0x800b02a115560543,0x3ff0000000000000,1
+np.float64,0x800b324a55766495,0x3ff0000000000000,1
+np.float64,0x800ffbcfd69ff7a0,0x3ff0000000000000,1
+np.float64,0x800830bc7b906179,0x3ff0000000000000,1
+np.float64,0x800cbafe383975fd,0x3ff0000000000000,1
+np.float64,0x8001ee42bfe3dc86,0x3ff0000000000000,1
+np.float64,0x8005b00fdc0b6020,0x3ff0000000000000,1
+np.float64,0x8005e7addd0bcf5c,0x3ff0000000000000,1
+np.float64,0x8001ae4cb0635c9a,0x3ff0000000000000,1
+np.float64,0x80098a9941131533,0x3ff0000000000000,1
+np.float64,0x800334c929466993,0x3ff0000000000000,1
+np.float64,0x8009568239d2ad05,0x3ff0000000000000,1
+np.float64,0x800f0639935e0c73,0x3ff0000000000000,1
+np.float64,0x800cebce7499d79d,0x3ff0000000000000,1
+np.float64,0x800482ee4c2905dd,0x3ff0000000000000,1
+np.float64,0x8007b7bd9e2f6f7c,0x3ff0000000000000,1
+np.float64,0x3fe654469f2ca88d,0x3fe8853f6c01ffb3,1
+np.float64,0x3feb4d7297369ae5,0x3fe50ad5bb621408,1
+np.float64,0x3feef53ba43dea77,0x3fe2283f356f8658,1
+np.float64,0x3fddf564eabbeaca,0x3fec8ec0e0dead9c,1
+np.float64,0x3fd3a69078274d21,0x3fee80e05c320000,1
+np.float64,0x3fecdafe5d39b5fd,0x3fe3d91a5d440fd9,1
+np.float64,0x3fd93286bc32650d,0x3fed8d40696cd10e,1
+np.float64,0x3fc0d34eb821a69d,0x3fefb954023d4284,1
+np.float64,0x3fc7b4b9a02f6973,0x3fef73e8739787ce,1
+np.float64,0x3fe08c839a611907,0x3febd0bc6f5641cd,1
+np.float64,0x3fb3d1758627a2eb,0x3fefe776f6183f96,1
+np.float64,0x3fef93c9ff3f2794,0x3fe1a4d2f622627d,1
+np.float64,0x3fea8d0041351a01,0x3fe59a52a1c78c9e,1
+np.float64,0x3fe3e26a30e7c4d4,0x3fea04ad3e0bbf8d,1
+np.float64,0x3fe5a34c9f6b4699,0x3fe8f57c5ccd1eab,1
+np.float64,0x3fc21ef859243df1,0x3fefae0b68a3a2e7,1
+np.float64,0x3fed7dd585fafbab,0x3fe35860041e5b0d,1
+np.float64,0x3fe5abacf22b575a,0x3fe8f03d8b6ef0f2,1
+np.float64,0x3fe426451f284c8a,0x3fe9dcf21f13205b,1
+np.float64,0x3fc01f6456203ec9,0x3fefbf19e2a8e522,1
+np.float64,0x3fe1cf2772239e4f,0x3feb2bbd645c7697,1
+np.float64,0x3fd18c4ace231896,0x3feecdfdd086c110,1
+np.float64,0x3fe8387d5b7070fb,0x3fe74358f2ec4910,1
+np.float64,0x3fdce51c2239ca38,0x3feccb2ae5459632,1
+np.float64,0x3fe5b0f2e4eb61e6,0x3fe8ecef4dbe4277,1
+np.float64,0x3fe1ceeb08a39dd6,0x3feb2bdd4dcfb3df,1
+np.float64,0x3febc5899d778b13,0x3fe4afc8dd8ad228,1
+np.float64,0x3fe7a47fbe2f48ff,0x3fe7a7fd9b352ea5,1
+np.float64,0x3fe7f74e1fafee9c,0x3fe76feb2755b247,1
+np.float64,0x3fe2bfad04e57f5a,0x3feaa9b46adddaeb,1
+np.float64,0x3fd06a090320d412,0x3feef40c334f8fba,1
+np.float64,0x3fdc97297d392e53,0x3fecdc16a3e22fcb,1
+np.float64,0x3fdc1a3f3838347e,0x3fecf6db2769d404,1
+np.float64,0x3fcca90096395201,0x3fef338156fcd218,1
+np.float64,0x3fed464733fa8c8e,0x3fe38483f0465d91,1
+np.float64,0x3fe7e067d82fc0d0,0x3fe77f7c8c9de896,1
+np.float64,0x3fc014fa0b2029f4,0x3fefbf6d84c933f8,1
+np.float64,0x3fd3bf1524277e2a,0x3fee7d2997b74dec,1
+np.float64,0x3fec153b86782a77,0x3fe472bb5497bb2a,1
+np.float64,0x3fd3e4d9d5a7c9b4,0x3fee776842691902,1
+np.float64,0x3fea6c0e2c74d81c,0x3fe5b2954cb458d9,1
+np.float64,0x3fee8f6a373d1ed4,0x3fe27bb9e348125b,1
+np.float64,0x3fd30c6dd42618dc,0x3fee97d2cab2b0bc,1
+np.float64,0x3fe4f90e6d69f21d,0x3fe95ea3dd4007f2,1
+np.float64,0x3fe271d467e4e3a9,0x3fead470d6d4008b,1
+np.float64,0x3fef2983897e5307,0x3fe1fd1a4debe33b,1
+np.float64,0x3fe980cc83b30199,0x3fe65d2fb8a0eb46,1
+np.float64,0x3fdfdf53db3fbea8,0x3fec1cf95b2a1cc7,1
+np.float64,0x3fe4d5307ba9aa61,0x3fe974701b4156cb,1
+np.float64,0x3fdb4e2345b69c47,0x3fed21aa6c146512,1
+np.float64,0x3fe3f7830327ef06,0x3fe9f85f6c88c2a8,1
+np.float64,0x3fca915fb63522bf,0x3fef502b73a52ecf,1
+np.float64,0x3fe66d3709ecda6e,0x3fe87531d7372d7a,1
+np.float64,0x3fd86000bcb0c001,0x3fedb5018dd684ca,1
+np.float64,0x3fe516e5feea2dcc,0x3fe94c68b111404e,1
+np.float64,0x3fd83c53dd3078a8,0x3fedbb9e5dd9e165,1
+np.float64,0x3fedfeeb673bfdd7,0x3fe2f0f0253c5d5d,1
+np.float64,0x3fe0dc6f9c21b8df,0x3feba8e2452410c2,1
+np.float64,0x3fbe154d643c2a9b,0x3fefc780a9357457,1
+np.float64,0x3fe5f63986abec73,0x3fe8c1434951a40a,1
+np.float64,0x3fbce0e50839c1ca,0x3fefcbeeaa27de75,1
+np.float64,0x3fd7ef5c5c2fdeb9,0x3fedc9c3022495b3,1
+np.float64,0x3fc1073914220e72,0x3fefb79de80fc0fd,1
+np.float64,0x3fe1a93c3d235278,0x3feb3fb21f86ac67,1
+np.float64,0x3fe321ee53e643dd,0x3fea72e2999f1e22,1
+np.float64,0x3fa881578c3102af,0x3feff69e6e51e0d6,1
+np.float64,0x3fd313482a262690,0x3fee96d161199495,1
+np.float64,0x3fe7272cd6ae4e5a,0x3fe7fbacbd0d8f43,1
+np.float64,0x3fd6cf4015ad9e80,0x3fedfd3513d544b8,1
+np.float64,0x3fc67b7e6d2cf6fd,0x3fef81f5c16923a4,1
+np.float64,0x3fa1999c14233338,0x3feffb2913a14184,1
+np.float64,0x3fc74eb8dd2e9d72,0x3fef78909a138e3c,1
+np.float64,0x3fc0b9274921724f,0x3fefba2ebd5f3e1c,1
+np.float64,0x3fd53fa156aa7f43,0x3fee40a18e952e88,1
+np.float64,0x3feaccbca4b59979,0x3fe56b22b33eb713,1
+np.float64,0x3fe6a01e3a2d403c,0x3fe8543fbd820ecc,1
+np.float64,0x3fd392a869a72551,0x3fee83e0ffe0e8de,1
+np.float64,0x3fe44d8928689b12,0x3fe9c5bf3c8fffdb,1
+np.float64,0x3fca3f209f347e41,0x3fef5461b6fa0924,1
+np.float64,0x3fee9e84b07d3d09,0x3fe26f638f733549,1
+np.float64,0x3faf49acb03e9359,0x3feff0b583cd8c48,1
+np.float64,0x3fea874b2af50e96,0x3fe59e882fa6febf,1
+np.float64,0x3fc50b72772a16e5,0x3fef918777dc41be,1
+np.float64,0x3fe861d1d4f0c3a4,0x3fe726e44d9d42c2,1
+np.float64,0x3fcadd2e2535ba5c,0x3fef4c3e2b56da38,1
+np.float64,0x3fea59c29cb4b385,0x3fe5c0043e586439,1
+np.float64,0x3fc1ffef0d23ffde,0x3fefaf22be452d13,1
+np.float64,0x3fc2d8dbc125b1b8,0x3fefa75b646d8e4e,1
+np.float64,0x3fd66c6471acd8c9,0x3fee0e5038b895c0,1
+np.float64,0x3fd0854adfa10a96,0x3feef0945bcc5c99,1
+np.float64,0x3feaac7076f558e1,0x3fe58316c23a82ad,1
+np.float64,0x3fdda49db3bb493b,0x3feca0e347c0ad6f,1
+np.float64,0x3fe43a539de874a7,0x3fe9d11d722d4822,1
+np.float64,0x3feeee3ebbfddc7d,0x3fe22dffd251e9af,1
+np.float64,0x3f8ee2c5b03dc58b,0x3fefff11855a7b6c,1
+np.float64,0x3fcd7107c63ae210,0x3fef2840bb55ca52,1
+np.float64,0x3f8d950d203b2a1a,0x3fefff253a08e40e,1
+np.float64,0x3fd40a5e57a814bd,0x3fee71a633c761fc,1
+np.float64,0x3fee836ec83d06de,0x3fe28580975be2fd,1
+np.float64,0x3fd7bbe87f2f77d1,0x3fedd31f661890cc,1
+np.float64,0xbfe05bf138a0b7e2,0x3febe8a000d96e47,1
+np.float64,0xbf88bddd90317bc0,0x3fefff66f6e2ff26,1
+np.float64,0xbfdc9cbb12393976,0x3fecdae2982335db,1
+np.float64,0xbfd85b4eccb0b69e,0x3fedb5e0dd87f702,1
+np.float64,0xbfe5c326cb2b864e,0x3fe8e180f525fa12,1
+np.float64,0xbfe381a0e4a70342,0x3fea3c8e5e3ab78e,1
+np.float64,0xbfe58d892c2b1b12,0x3fe9031551617aed,1
+np.float64,0xbfd7f3a52cafe74a,0x3fedc8fa97edd080,1
+np.float64,0xbfef3417bc7e682f,0x3fe1f45989f6a009,1
+np.float64,0xbfddfb8208bbf704,0x3fec8d5fa9970773,1
+np.float64,0xbfdab69bcc356d38,0x3fed40b2f6c347c6,1
+np.float64,0xbfed3f7cf17a7efa,0x3fe389e4ff4d9235,1
+np.float64,0xbfe47675d9a8ecec,0x3fe9ad6829a69e94,1
+np.float64,0xbfd030e2902061c6,0x3feefb3f811e024f,1
+np.float64,0xbfc376ac7226ed58,0x3fefa1798712b37e,1
+np.float64,0xbfdb7e54a0b6fcaa,0x3fed17a974c4bc28,1
+np.float64,0xbfdb7d5d5736faba,0x3fed17dcf31a8d84,1
+np.float64,0xbf876bd6502ed7c0,0x3fefff76dce6232c,1
+np.float64,0xbfd211e6c02423ce,0x3feebba41f0a1764,1
+np.float64,0xbfb443e3962887c8,0x3fefe658953629d4,1
+np.float64,0xbfe81b09e9b03614,0x3fe757882e4fdbae,1
+np.float64,0xbfdcb905d2b9720c,0x3fecd4c22cfe84e5,1
+np.float64,0xbfe3b62d99276c5b,0x3fea1e5520b3098d,1
+np.float64,0xbfbf05b25c3e0b68,0x3fefc3ecc04bca8e,1
+np.float64,0xbfdedc885b3db910,0x3fec59e22feb49f3,1
+np.float64,0xbfe33aa282667545,0x3fea64f2d55ec471,1
+np.float64,0xbfec84745a3908e9,0x3fe41cb3214e7044,1
+np.float64,0xbfddefdff1bbdfc0,0x3fec8fff88d4d0ec,1
+np.float64,0xbfd26ae6aca4d5ce,0x3feeaf208c7fedf6,1
+np.float64,0xbfee010591fc020b,0x3fe2ef3e57211a5e,1
+np.float64,0xbfb8cfddca319fb8,0x3fefd98d8f7918ed,1
+np.float64,0xbfe991648f3322c9,0x3fe6514e54670bae,1
+np.float64,0xbfee63fd087cc7fa,0x3fe29f1bfa3297cc,1
+np.float64,0xbfe1685942a2d0b2,0x3feb617f5f839eee,1
+np.float64,0xbfc6fc2fd62df860,0x3fef7c4698fd58cf,1
+np.float64,0xbfe42723d3a84e48,0x3fe9dc6ef7243e90,1
+np.float64,0xbfc3a7e89d274fd0,0x3fef9f99e3314e77,1
+np.float64,0xbfeb4c9521f6992a,0x3fe50b7c919bc6d8,1
+np.float64,0xbf707b34e020f680,0x3fefffef05e30264,1
+np.float64,0xbfc078478e20f090,0x3fefbc479305d5aa,1
+np.float64,0xbfd494ac4ca92958,0x3fee5c11f1cd8269,1
+np.float64,0xbfdaf888a035f112,0x3fed3346ae600469,1
+np.float64,0xbfa5d8ed502bb1e0,0x3feff88b0f262609,1
+np.float64,0xbfeec0cbfffd8198,0x3fe253543b2371cb,1
+np.float64,0xbfe594b5986b296b,0x3fe8fe9b39fb3940,1
+np.float64,0xbfc8ece7c631d9d0,0x3fef652bd0611ac7,1
+np.float64,0xbfd8ffeca0b1ffda,0x3fed96ebdf9b65cb,1
+np.float64,0xbfba9b221e353648,0x3fefd3cc21e2f15c,1
+np.float64,0xbfca63a52c34c74c,0x3fef52848eb9ed3b,1
+np.float64,0xbfe588e9b06b11d4,0x3fe905f7403e8881,1
+np.float64,0xbfc76f82db2edf04,0x3fef77138fe9bbc2,1
+np.float64,0xbfeeb3f334bd67e6,0x3fe25ddadb1096d6,1
+np.float64,0xbfbf2b64ce3e56c8,0x3fefc35a9555f6df,1
+np.float64,0xbfe9920e4ff3241c,0x3fe650d4ab8f5c42,1
+np.float64,0xbfb4a54c02294a98,0x3fefe55fc85ae5e9,1
+np.float64,0xbfe353b0c766a762,0x3fea56c02d17e4b7,1
+np.float64,0xbfd99961a4b332c4,0x3fed795fcd00dbf9,1
+np.float64,0xbfef191ddabe323c,0x3fe20aa79524f636,1
+np.float64,0xbfb25d060224ba10,0x3fefeaeee5cc8c0b,1
+np.float64,0xbfe6022428ec0448,0x3fe8b9b46e776194,1
+np.float64,0xbfed1a236cba3447,0x3fe3a76bee0d9861,1
+np.float64,0xbfc59671e72b2ce4,0x3fef8bc4daef6f14,1
+np.float64,0xbfdf2711703e4e22,0x3fec4886a8c9ceb5,1
+np.float64,0xbfeb7e207536fc41,0x3fe4e610c783f168,1
+np.float64,0xbfe6cdf5bcad9bec,0x3fe8365f8a59bc81,1
+np.float64,0xbfe55294adaaa52a,0x3fe927b0af5ccd09,1
+np.float64,0xbfdf4a88913e9512,0x3fec4036df58ba74,1
+np.float64,0xbfebb7efe4376fe0,0x3fe4ba276006992d,1
+np.float64,0xbfe09f29cfa13e54,0x3febc77f4f9c95e7,1
+np.float64,0xbfdf8c75653f18ea,0x3fec30ac924e4f46,1
+np.float64,0xbfefd601c7ffac04,0x3fe16d6f21bcb9c1,1
+np.float64,0xbfeae97ff5f5d300,0x3fe555bb5b87efe9,1
+np.float64,0xbfed427f02fa84fe,0x3fe387830db093bc,1
+np.float64,0xbfa33909cc267210,0x3feffa3a1bcb50dd,1
+np.float64,0xbfe9aa4bf5f35498,0x3fe63f6e98f6aa0f,1
+np.float64,0xbfe2d7349b25ae69,0x3fea9caa7c331e7e,1
+np.float64,0xbfcdbb2a3a3b7654,0x3fef2401c9659e4b,1
+np.float64,0xbfc8a90919315214,0x3fef686fe7fc0513,1
+np.float64,0xbfe62a98df2c5532,0x3fe89ff22a02cc6b,1
+np.float64,0xbfdc0f67b3b81ed0,0x3fecf928b637798f,1
+np.float64,0xbfebb32bf6f76658,0x3fe4bdc893c09698,1
+np.float64,0xbfec067996380cf3,0x3fe47e132741db97,1
+np.float64,0xbfd9774e1d32ee9c,0x3fed7ffe1e87c434,1
+np.float64,0xbfef989890bf3131,0x3fe1a0d025c80cf4,1
+np.float64,0xbfe59887e62b3110,0x3fe8fc382a3d4197,1
+np.float64,0xbfdea0a11e3d4142,0x3fec67b987e236ec,1
+np.float64,0xbfe2ec495825d892,0x3fea90efb231602d,1
+np.float64,0xbfb329c5c2265388,0x3fefe90f1b8209c3,1
+np.float64,0xbfdcd2dcd339a5ba,0x3feccf24c60b1478,1
+np.float64,0xbfe537ea18aa6fd4,0x3fe938237e217fe0,1
+np.float64,0xbfe8675ce170ceba,0x3fe723105925ce3a,1
+np.float64,0xbfd70723acae0e48,0x3fedf369ac070e65,1
+np.float64,0xbfea9d8692b53b0d,0x3fe58e1ee42e3fdb,1
+np.float64,0xbfcfeb96653fd72c,0x3fef029770033bdc,1
+np.float64,0xbfcc06c92d380d94,0x3fef3c69797d9b0a,1
+np.float64,0xbfe16b7c4f62d6f8,0x3feb5fdf9f0a9a07,1
+np.float64,0xbfed4d7a473a9af4,0x3fe37ecee27b1eb7,1
+np.float64,0xbfe6a6f6942d4ded,0x3fe84fccdf762b19,1
+np.float64,0xbfda46d867348db0,0x3fed572d928fa657,1
+np.float64,0xbfdbd9482db7b290,0x3fed049b5f907b52,1
+np.float64,0x7fe992ceb933259c,0xbfeb15af92aad70e,1
+np.float64,0x7fe3069204a60d23,0xbfe5eeff454240e9,1
+np.float64,0x7fe729dbf32e53b7,0xbfefe0528a330e4c,1
+np.float64,0x7fec504fb638a09e,0x3fd288e95dbedf65,1
+np.float64,0x7fe1d30167a3a602,0xbfeffc41f946fd02,1
+np.float64,0x7fed7f8ffd3aff1f,0x3fefe68ec604a19d,1
+np.float64,0x7fd2f23635a5e46b,0x3fea63032efbb447,1
+np.float64,0x7fd4c86db1a990da,0x3fdf6b9f7888db5d,1
+np.float64,0x7fe7554db6eeaa9a,0x3fe1b41476861bb0,1
+np.float64,0x7fe34e823ba69d03,0x3fefc435532e6294,1
+np.float64,0x7fec5c82fef8b905,0x3fef8f0c6473034f,1
+np.float64,0x7feba221bff74442,0xbfea95b81eb19b47,1
+np.float64,0x7fe74808a5ae9010,0xbfd3aa322917c3e5,1
+np.float64,0x7fdf41b7e0be836f,0x3fd14283c7147282,1
+np.float64,0x7fec09892f381311,0x3fe5240376ae484b,1
+np.float64,0x7faaf80bf435f017,0x3fe20227fa811423,1
+np.float64,0x7f8422d8402845b0,0x3fe911714593b8a0,1
+np.float64,0x7fd23a7fada474fe,0x3feff9f40aa37e9c,1
+np.float64,0x7fef4a4806fe948f,0x3fec6eca89cb4a62,1
+np.float64,0x7fe1e71cf763ce39,0xbfea6ac63f9ba457,1
+np.float64,0x7fe3e555be27caaa,0xbfe75b305d0dbbfd,1
+np.float64,0x7fcb8bac96371758,0xbfe8b126077f9d4c,1
+np.float64,0x7fc98e2c84331c58,0x3fef9092eb0bc85a,1
+np.float64,0x7fe947cf2b728f9d,0xbfebfff2c5b7d198,1
+np.float64,0x7feee8058c3dd00a,0xbfef21ebaae2eb17,1
+np.float64,0x7fef61d8d5bec3b1,0xbfdf1a032fb1c864,1
+np.float64,0x7fcf714b6f3ee296,0x3fe6fc89a8084098,1
+np.float64,0x7fa9a8b44c335168,0xbfeb16c149cea943,1
+np.float64,0x7fd175c482a2eb88,0xbfef64d341e73f88,1
+np.float64,0x7feab8e6a87571cc,0x3feb10069c397464,1
+np.float64,0x7fe3ade72de75bcd,0x3fd1753e333d5790,1
+np.float64,0x7fb26d87d224db0f,0xbfe753d36b18f4ca,1
+np.float64,0x7fdb7ef159b6fde2,0x3fe5c0a6044d3607,1
+np.float64,0x7fd5af86422b5f0c,0x3fe77193c95f6484,1
+np.float64,0x7fee9e00b07d3c00,0x3fe864d494596845,1
+np.float64,0x7fef927a147f24f3,0xbfe673b14715693d,1
+np.float64,0x7fd0aea63c215d4b,0xbfeff435f119fce9,1
+np.float64,0x7fd02e3796a05c6e,0x3fe4f7e3706e9a3d,1
+np.float64,0x7fd3ed61da27dac3,0xbfefef2f057f168c,1
+np.float64,0x7fefaca0d4ff5941,0x3fd3e8ad205cd4ab,1
+np.float64,0x7feb659e06f6cb3b,0x3fd64d803203e027,1
+np.float64,0x7fc94ccfaf32999e,0x3fee04922209369a,1
+np.float64,0x7feb4ec294f69d84,0xbfd102763a056c89,1
+np.float64,0x7fe2ada6ac655b4c,0x3fef4f6792aa6093,1
+np.float64,0x7fe5f40fdc2be81f,0xbfb4a6327186eee8,1
+np.float64,0x7fe7584bc3eeb097,0xbfd685b8ff94651d,1
+np.float64,0x7fe45d276be8ba4e,0x3fee53b13f7e442f,1
+np.float64,0x7fe6449b3d6c8935,0xbfe7e08bafa75251,1
+np.float64,0x7f8d62e6b03ac5cc,0x3fe73d30762f38fd,1
+np.float64,0x7fe3a76f72a74ede,0xbfeb48a28bc60968,1
+np.float64,0x7fd057706920aee0,0x3fdece8fa06f626c,1
+np.float64,0x7fe45ae158e8b5c2,0x3fe7a70f47b4d349,1
+np.float64,0x7fea8a5a983514b4,0x3fefb053d5f9ddd7,1
+np.float64,0x7fdd1e86ab3a3d0c,0x3fe3cded1b93816b,1
+np.float64,0x7fdb456108b68ac1,0xbfe37574c0b9bf8f,1
+np.float64,0x7fe972602432e4bf,0x3fef9a26e65ec01c,1
+np.float64,0x7fdbe2385637c470,0x3fed541df57969e1,1
+np.float64,0x7fe57f03602afe06,0x3fbd90f595cbbd94,1
+np.float64,0x7feb0ceb68f619d6,0xbfeae9cb8ee5261f,1
+np.float64,0x7fe6abfe6c6d57fc,0xbfef40a6edaca26f,1
+np.float64,0x7fe037ea08606fd3,0xbfda817d75858597,1
+np.float64,0x7fdd75a52dbaeb49,0x3feef2a0d91d6aa1,1
+np.float64,0x7fe8f9af66b1f35e,0xbfedfceef2a3bfc9,1
+np.float64,0x7fedf762b53beec4,0x3fd8b4f21ef69ee3,1
+np.float64,0x7fe99295b7f3252a,0x3feffc24d970383e,1
+np.float64,0x7fe797b0172f2f5f,0x3fee089aa56f7ce8,1
+np.float64,0x7fed89dcc97b13b9,0xbfcfa2bb0c3ea41f,1
+np.float64,0x7fae9e8d5c3d3d1a,0xbfe512ffe16c6b08,1
+np.float64,0x7fefaecbe27f5d97,0x3fbfc718a5e972f1,1
+np.float64,0x7fce0236d93c046d,0xbfa9b7cd790db256,1
+np.float64,0x7fa9689aac32d134,0x3feced501946628a,1
+np.float64,0x7feb1469e93628d3,0x3fef2a988e7673ed,1
+np.float64,0x7fdba78344b74f06,0xbfe092e78965b30c,1
+np.float64,0x7fece54c3fb9ca97,0x3fd3cfd184bed2e6,1
+np.float64,0x7fdb84212b370841,0xbfe25ebf2db6ee55,1
+np.float64,0x7fbe3e8bf23c7d17,0x3fe2ee72df573345,1
+np.float64,0x7fe43d9803687b2f,0xbfed2eff6a9e66a0,1
+np.float64,0x7fb0f9c00a21f37f,0x3feff70f3276fdb7,1
+np.float64,0x7fea0c6cbbb418d8,0xbfefa612494798b2,1
+np.float64,0x7fe4b3239e296646,0xbfe74dd959af8cdc,1
+np.float64,0x7fe5c6a773eb8d4e,0xbfd06944048f8d2b,1
+np.float64,0x7fb1c1278223824e,0xbfeb533a34655bde,1
+np.float64,0x7fd21c09ee243813,0xbfe921ccbc9255c3,1
+np.float64,0x7fe051020c20a203,0x3fbd519d700c1f2f,1
+np.float64,0x7fe0c76845e18ed0,0x3fefb9595191a31b,1
+np.float64,0x7fe6b0b57b6d616a,0xbf8c59a8ba5fcd9a,1
+np.float64,0x7fd386c460270d88,0x3fe8ffea5d1a5c46,1
+np.float64,0x7feeb884713d7108,0x3fee9b2247ef6c0d,1
+np.float64,0x7fd85f71b6b0bee2,0xbfefc30ec3e28f07,1
+np.float64,0x7fc341366426826c,0x3fd4234d35386d3b,1
+np.float64,0x7fe56482dd6ac905,0x3fe7189de6a50668,1
+np.float64,0x7fec67a2e3f8cf45,0xbfef86d0b940f37f,1
+np.float64,0x7fe38b202fe7163f,0x3feb90b75caa2030,1
+np.float64,0x7fdcbc64883978c8,0x3fed4f758fbf64d4,1
+np.float64,0x7fea5f0598f4be0a,0x3fdd503a417b3d4d,1
+np.float64,0x7fda3b6bcf3476d7,0x3fea6e9af3f7f9f5,1
+np.float64,0x7fc7d7896c2faf12,0x3fda2bebc36a2363,1
+np.float64,0x7fe7e8e2626fd1c4,0xbfe7d5e390c4cc3f,1
+np.float64,0x7fde0f3d7abc1e7a,0xbfede7a0ecfa3606,1
+np.float64,0x7fc692b8f52d2571,0x3feff0cd7ab6f61b,1
+np.float64,0xff92d1fce825a400,0xbfc921c36fc014fa,1
+np.float64,0xffdec3af2fbd875e,0xbfed6a77e6a0364e,1
+np.float64,0xffef46e7d9be8dcf,0xbfed7d39476f7e27,1
+np.float64,0xffe2c2ce4525859c,0x3fe1757261316bc9,1
+np.float64,0xffe27c8b5864f916,0xbfefe017c0d43457,1
+np.float64,0xffe184d7442309ae,0x3fa1fb8c49dba596,1
+np.float64,0xffddf5f98d3bebf4,0x3fee4f8eaa5f847e,1
+np.float64,0xffee3ef354fc7de6,0xbfebfd60fa51b2ba,1
+np.float64,0xffdecb3e85bd967e,0x3fbfad2667a8b468,1
+np.float64,0xffe4ee900b29dd20,0xbfdc02dc626f91cd,1
+np.float64,0xffd3179f6da62f3e,0xbfe2cfe442511776,1
+np.float64,0xffe99ef7cef33def,0x3f50994542a7f303,1
+np.float64,0xffe2b66b1ae56cd6,0xbfefe3e066eb6329,1
+np.float64,0xff8f72aff03ee540,0x3fe9c46224cf5003,1
+np.float64,0xffd29beb85a537d8,0x3fefcb0b6166be71,1
+np.float64,0xffaef02d4c3de060,0xbfef5fb71028fc72,1
+np.float64,0xffd39a2a89273456,0x3fe6d4b183205dca,1
+np.float64,0xffef8a9392ff1526,0x3fedb99fbf402468,1
+np.float64,0xffb9b3f31e3367e8,0x3fee1005270fcf80,1
+np.float64,0xffed9d5c693b3ab8,0x3fd110f4b02365d5,1
+np.float64,0xffeaba45f9f5748b,0x3fe499e0a6f4afb2,1
+np.float64,0xffdba3f70d3747ee,0xbfca0c30493ae519,1
+np.float64,0xffa35b985426b730,0xbfdb625df56bcf45,1
+np.float64,0xffccbc9728397930,0x3fc53cbc59020704,1
+np.float64,0xffef73c942bee792,0xbfdc647a7a5e08be,1
+np.float64,0xffcb5acfb236b5a0,0x3feeb4ec038c39fc,1
+np.float64,0xffea116fe2b422df,0x3fefe03b6ae0b435,1
+np.float64,0xffe97de6e7b2fbcd,0xbfd2025698fab9eb,1
+np.float64,0xffdddba314bbb746,0x3fd31f0fdb8f93be,1
+np.float64,0xffd613a24a2c2744,0xbfebbb1efae884b3,1
+np.float64,0xffe3d938aa67b271,0xbfc2099cead3d3be,1
+np.float64,0xffdf08c2e33e1186,0xbfefd236839b900d,1
+np.float64,0xffea6ba8bd34d751,0x3fe8dfc032114719,1
+np.float64,0xffe3202083e64040,0x3fed513b81432a22,1
+np.float64,0xffb2397db62472f8,0xbfee7d7fe1c3f76c,1
+np.float64,0xffd9d0682ab3a0d0,0x3fe0bcf9e531ad79,1
+np.float64,0xffc293df202527c0,0xbfe58d0bdece5e64,1
+np.float64,0xffe1422c7da28458,0xbf81bd72595f2341,1
+np.float64,0xffd64e4ed4ac9c9e,0x3fa4334cc011c703,1
+np.float64,0xffe40a970ae8152e,0x3fead3d258b55b7d,1
+np.float64,0xffc8c2f2223185e4,0xbfef685f07c8b9fd,1
+np.float64,0xffe4b2f7216965ee,0x3fe3861d3d896a83,1
+np.float64,0xffdb531db3b6a63c,0x3fe18cb8332dd59d,1
+np.float64,0xffe8e727a3b1ce4e,0xbfe57b15abb677b9,1
+np.float64,0xffe530c1e12a6184,0xbfb973ea5535e48f,1
+np.float64,0xffe6f7849cedef08,0x3fd39a37ec5af4b6,1
+np.float64,0xffead62a78b5ac54,0x3fe69b3f6c7aa24b,1
+np.float64,0xffeefdd725fdfbad,0xbfc08a456111fdd5,1
+np.float64,0xffe682182fed0430,0x3fecc7c1292761d2,1
+np.float64,0xffee0ca8dcbc1951,0x3fef6cc361ef2c19,1
+np.float64,0xffec9b338f393666,0x3fefa9ab8e0471b5,1
+np.float64,0xffe13c5e29a278bc,0xbfef8da74ad83398,1
+np.float64,0xffd7bd48c62f7a92,0x3fe3468cd4ac9d34,1
+np.float64,0xffedd0ed14bba1d9,0xbfd563a83477077b,1
+np.float64,0xffe86b83f3f0d707,0x3fe9eb3c658e4b2d,1
+np.float64,0xffd6a4db4bad49b6,0xbfc7e11276166e17,1
+np.float64,0xffc29e8404253d08,0x3fd35971961c789f,1
+np.float64,0xffe27cf3d664f9e7,0xbfeca0f73c72f810,1
+np.float64,0xffc34152352682a4,0x3fef384e564c002c,1
+np.float64,0xffe395728ba72ae4,0x3f8fe18c2de86eba,1
+np.float64,0xffed86c4fbbb0d89,0x3fef709db881c672,1
+np.float64,0xffe8a98d37f1531a,0x3fd4879c8f73c3dc,1
+np.float64,0xffb8ce9fea319d40,0xbfb853c8fe46b08d,1
+np.float64,0xffe7f26db8efe4db,0xbfec1cfd3e5c2ac1,1
+np.float64,0xffd7935b77af26b6,0x3fb7368c89b2a460,1
+np.float64,0xffc5840ed02b081c,0x3fd92220b56631f3,1
+np.float64,0xffc36a873926d510,0x3fa84d61baf61811,1
+np.float64,0xffe06ea583e0dd4a,0x3feb647e348b9e39,1
+np.float64,0xffe6a33031ed4660,0xbfe096b851dc1a0a,1
+np.float64,0xffe001c938e00392,0x3fe4eece77623e7a,1
+np.float64,0xffc1e4f23b23c9e4,0xbfdb9bb1f83f6ac4,1
+np.float64,0xffecd3ecbab9a7d9,0x3fbafb1f800f177d,1
+np.float64,0xffc2d3016825a604,0xbfef650e8b0d6afb,1
+np.float64,0xffe222cb68e44596,0x3fde3690e44de5bd,1
+np.float64,0xffe5bb145e2b7628,0x3fedbb98e23c9dc1,1
+np.float64,0xffe9e5823b73cb04,0xbfee41661016c03c,1
+np.float64,0xffd234a00ba46940,0x3fda0312cda580c2,1
+np.float64,0xffe0913ed6e1227d,0xbfed508bb529bd23,1
+np.float64,0xffe8e3596171c6b2,0xbfdc33e1c1d0310e,1
+np.float64,0xffef9c6835ff38cf,0x3fea8ce6d27dfba3,1
+np.float64,0xffdd3bcf66ba779e,0x3fe50523d2b6470e,1
+np.float64,0xffe57e8cf06afd1a,0xbfee600933347247,1
+np.float64,0xffe0d8c65fa1b18c,0x3fe75091f93d5e4c,1
+np.float64,0xffea7c8c16b4f918,0x3fee681724795198,1
+np.float64,0xffe34f7a05269ef4,0xbfe3c3e179676f13,1
+np.float64,0xffd28894a6a5112a,0xbfe5d1027aee615d,1
+np.float64,0xffc73be6f22e77cc,0x3fe469bbc08b472a,1
+np.float64,0xffe7f71b066fee36,0x3fe7ed136c8fdfaa,1
+np.float64,0xffebc13e29f7827c,0x3fefcdc6e677d314,1
+np.float64,0xffd53e9c942a7d3a,0x3fea5a02c7341749,1
+np.float64,0xffd7191b23ae3236,0x3fea419b66023443,1
+np.float64,0xffe9480325b29006,0xbfefeaff5fa38cd5,1
+np.float64,0xffba46dc0e348db8,0xbfefa54f4de28eba,1
+np.float64,0xffdd4cc31eba9986,0x3fe60bb41fe1c4da,1
+np.float64,0xffe13a70dea274e1,0xbfaa9192f7bd6c9b,1
+np.float64,0xffde25127bbc4a24,0x3f7c75f45e29be7d,1
+np.float64,0xffe4076543a80eca,0x3fea5aad50d2f687,1
+np.float64,0xffe61512acec2a25,0xbfefffeb67401649,1
+np.float64,0xffef812ec1ff025d,0xbfe919c7c073c766,1
+np.float64,0xffd5552aeaaaaa56,0x3fc89d38ab047396,1

shared/package-files/d0/d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57/blob

@@ -0,0 +1,3 @@
+# Deprecated alias for xml.etree.ElementTree
+
+from xml.etree.ElementTree import *

shared/package-files/d0/d0fa53f32abd96d97fb96c50fd0a05d30f83d667315dcaa20ae2f22c52b36f62/blob

@@ -0,0 +1,70 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/arange_ops.h>
+
+namespace at {
+
+
+// aten::arange(Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor arange(const at::Scalar & end, at::TensorOptions options={}) {
+    return at::_ops::arange::call(end, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+}
+// aten::arange(Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor arange(const at::Scalar & end, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::arange::call(end, dtype, layout, device, pin_memory);
+}
+
+// aten::arange.start(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, at::TensorOptions options={}) {
+    return at::_ops::arange_start::call(start, end, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+}
+// aten::arange.start(Scalar start, Scalar end, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::arange_start::call(start, end, dtype, layout, device, pin_memory);
+}
+
+// aten::arange.start_step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::TensorOptions options={}) {
+    return at::_ops::arange_start_step::call(start, end, step, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt());
+}
+// aten::arange.start_step(Scalar start, Scalar end, Scalar step=1, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor
+inline at::Tensor arange(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, c10::optional<at::ScalarType> dtype, c10::optional<at::Layout> layout, c10::optional<at::Device> device, c10::optional<bool> pin_memory) {
+    return at::_ops::arange_start_step::call(start, end, step, dtype, layout, device, pin_memory);
+}
+
+// aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & arange_out(at::Tensor & out, const at::Scalar & end) {
+    return at::_ops::arange_out::call(end, out);
+}
+// aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & arange_outf(const at::Scalar & end, at::Tensor & out) {
+    return at::_ops::arange_out::call(end, out);
+}
+
+// aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & arange_out(at::Tensor & out, const at::Scalar & start, const at::Scalar & end, const at::Scalar & step) {
+    return at::_ops::arange_start_out::call(start, end, step, out);
+}
+// aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & arange_outf(const at::Scalar & start, const at::Scalar & end, const at::Scalar & step, at::Tensor & out) {
+    return at::_ops::arange_start_out::call(start, end, step, out);
+}
+
+}

shared/package-files/d0/d0faa9d7997d5696bff92384144e0b9dfb2e4c38375817613f81a89c06ec6383/blob

@@ -0,0 +1,6 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset es_MX DATE_FORMAT "%e/%m/%Y"
+    ::msgcat::mcset es_MX TIME_FORMAT_12 "%I:%M:%S %P"
+    ::msgcat::mcset es_MX DATE_TIME_FORMAT "%e/%m/%Y %I:%M:%S %P %z"
+}

shared/package-files/d0/d0fcf91bf804e5e905af4c010a43f3cd87f9d21b099be08934a5acceab609ddf/blob

@@ -0,0 +1,272 @@
+import importlib
+import json
+import os
+import random
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, List, Optional
+import hashlib
+
+
+def default_cache_dir():
+    return os.path.join(Path.home(), ".triton", "cache")
+
+
+def default_override_dir():
+    return os.path.join(Path.home(), ".triton", "override")
+
+
+def default_dump_dir():
+    return os.path.join(Path.home(), ".triton", "dump")
+
+
+class CacheManager(ABC):
+
+    def __init__(self, key):
+        pass
+
+    @abstractmethod
+    def get_file(self, filename) -> Optional[str]:
+        pass
+
+    @abstractmethod
+    def put(self, data, filename, binary=True) -> str:
+        pass
+
+    @abstractmethod
+    def get_group(self, filename: str) -> Optional[Dict[str, str]]:
+        pass
+
+    @abstractmethod
+    def put_group(self, filename: str, group: Dict[str, str]):
+        pass
+
+
+class FileCacheManager(CacheManager):
+
+    def __init__(self, key, override=False, dump=False):
+        self.key = key
+        self.lock_path = None
+        if dump:
+            self.cache_dir = default_dump_dir()
+            self.cache_dir = os.path.join(self.cache_dir, self.key)
+            self.lock_path = os.path.join(self.cache_dir, "lock")
+            os.makedirs(self.cache_dir, exist_ok=True)
+        elif override:
+            self.cache_dir = default_override_dir()
+            self.cache_dir = os.path.join(self.cache_dir, self.key)
+        else:
+            # create cache directory if it doesn't exist
+            self.cache_dir = os.getenv("TRITON_CACHE_DIR", "").strip() or default_cache_dir()
+            if self.cache_dir:
+                self.cache_dir = os.path.join(self.cache_dir, self.key)
+                self.lock_path = os.path.join(self.cache_dir, "lock")
+                os.makedirs(self.cache_dir, exist_ok=True)
+            else:
+                raise RuntimeError("Could not create or locate cache dir")
+
+    def _make_path(self, filename) -> str:
+        return os.path.join(self.cache_dir, filename)
+
+    def _has_file(self, filename) -> bool:
+        if not self.cache_dir:
+            raise RuntimeError("Could not create or locate cache dir")
+        return os.path.exists(self._make_path(filename))
+
+    def get_file(self, filename) -> Optional[str]:
+        if self._has_file(filename):
+            return self._make_path(filename)
+        else:
+            return None
+
+    def get_group(self, filename: str) -> Optional[Dict[str, str]]:
+        grp_filename = f"__grp__{filename}"
+        if not self._has_file(grp_filename):
+            return None
+        grp_filepath = self._make_path(grp_filename)
+        with open(grp_filepath) as f:
+            grp_data = json.load(f)
+        child_paths = grp_data.get("child_paths", None)
+        # Invalid group data.
+        if child_paths is None:
+            return None
+        result = {}
+        for c in child_paths:
+            p = self._make_path(c)
+            if os.path.exists(p):
+                result[c] = p
+        return result
+
+    # Note a group of pushed files as being part of a group
+    def put_group(self, filename: str, group: Dict[str, str]) -> str:
+        if not self.cache_dir:
+            raise RuntimeError("Could not create or locate cache dir")
+        grp_contents = json.dumps({"child_paths": sorted(list(group.keys()))})
+        grp_filename = f"__grp__{filename}"
+        return self.put(grp_contents, grp_filename, binary=False)
+
+    def put(self, data, filename, binary=True) -> str:
+        if not self.cache_dir:
+            raise RuntimeError("Could not create or locate cache dir")
+        binary = isinstance(data, bytes)
+        if not binary:
+            data = str(data)
+        assert self.lock_path is not None
+        filepath = self._make_path(filename)
+        # Random ID to avoid any collisions
+        rnd_id = random.randint(0, 1000000)
+        # we use the PID incase a bunch of these around so we can see what PID made it
+        pid = os.getpid()
+        # use tempfile to be robust against program interruptions
+        temp_path = f"{filepath}.tmp.pid_{pid}_{rnd_id}"
+        mode = "wb" if binary else "w"
+        with open(temp_path, mode) as f:
+            f.write(data)
+        # Replace is guaranteed to be atomic on POSIX systems if it succeeds
+        # so filepath cannot see a partial write
+        os.replace(temp_path, filepath)
+        return filepath
+
+
+class RemoteCacheBackend:
+    """
+    A backend implementation for accessing a remote/distributed cache.
+    """
+
+    def __init__(self, key: str):
+        pass
+
+    @abstractmethod
+    def get(self, filenames: List[str]) -> Dict[str, bytes]:
+        pass
+
+    @abstractmethod
+    def put(self, filename: str, data: bytes):
+        pass
+
+
+class RedisRemoteCacheBackend(RemoteCacheBackend):
+
+    def __init__(self, key):
+        import redis
+        self._key = key
+        self._key_fmt = os.environ.get("TRITON_REDIS_KEY_FORMAT", "triton:{key}:{filename}")
+        self._redis = redis.Redis(
+            host=os.environ.get("TRITON_REDIS_HOST", "localhost"),
+            port=int(os.environ.get("TRITON_REDIS_PORT", 6379)),
+        )
+
+    def _get_key(self, filename: str) -> str:
+        return self._key_fmt.format(key=self._key, filename=filename)
+
+    def get(self, filenames: List[str]) -> Dict[str, str]:
+        results = self._redis.mget([self._get_key(f) for f in filenames])
+        return {filename: result for filename, result in zip(filenames, results) if result is not None}
+
+    def put(self, filename: str, data: bytes) -> Dict[str, bytes]:
+        self._redis.set(self._get_key(filename), data)
+
+
+class RemoteCacheManager(CacheManager):
+
+    def __init__(self, key, override=False, dump=False):
+        # Setup backend pointed too by `TRITON_REMOTE_CACHE_BACKEND`.
+        remote_cache_manager = os.environ["TRITON_REMOTE_CACHE_BACKEND"]
+        module_path, clz_nme = remote_cache_manager.split(":")
+        module = importlib.import_module(module_path)
+        remote_cache_cls = getattr(module, clz_nme)
+        self._backend = remote_cache_cls(key)
+
+        self._override = override
+        self._dump = dump
+
+        # Use a `FileCacheManager` to materialize remote cache paths locally.
+        self._file_cache_manager = FileCacheManager(key, override=override, dump=dump)
+
+    def _materialize(self, filename: str, data: bytes):
+        # We use a backing `FileCacheManager` to provide the materialized data.
+        return self._file_cache_manager.put(data, filename, binary=True)
+
+    def get_file(self, filename: str) -> Optional[str]:
+        # We don't handle the dump/override cases.
+        if self._dump or self._override:
+            return self._file_cache_manager.get_file(filename)
+
+        # We always check the remote cache backend -- even if our internal file-
+        # based cache has the item -- to make sure LRU accounting works as
+        # expected.
+        results = self._backend.get([filename])
+        if len(results) == 0:
+            return None
+        (_, data), = results.items()
+        return self._materialize(filename, data)
+
+    def put(self, data, filename: str, binary=True) -> str:
+        # We don't handle the dump/override cases.
+        if self._dump or self._override:
+            return self._file_cache_manager.put(data, filename, binary=binary)
+
+        if not isinstance(data, bytes):
+            data = str(data).encode("utf-8")
+        self._backend.put(filename, data)
+        return self._materialize(filename, data)
+
+    def get_group(self, filename: str) -> Optional[Dict[str, str]]:
+        # We don't handle the dump/override cases.
+        if self._dump or self._override:
+            return self._file_cache_manager.get_group(filename)
+
+        grp_filename = f"__grp__{filename}"
+        grp_filepath = self.get_file(grp_filename)
+        if grp_filepath is None:
+            return None
+        with open(grp_filepath) as f:
+            grp_data = json.load(f)
+        child_paths = grp_data.get("child_paths", None)
+
+        result = None
+
+        # Found group data.
+        if child_paths is not None:
+            result = {}
+            for child_path, data in self._backend.get(child_paths).items():
+                result[child_path] = self._materialize(child_path, data)
+
+        return result
+
+    def put_group(self, filename: str, group: Dict[str, str]):
+        # We don't handle the dump/override cases.
+        if self._dump or self._override:
+            return self._file_cache_manager.put_group(filename, group)
+
+        grp_contents = json.dumps({"child_paths": sorted(list(group.keys()))})
+        grp_filename = f"__grp__{filename}"
+        return self.put(grp_contents, grp_filename)
+
+
+__cache_cls = FileCacheManager
+__cache_cls_nme = "DEFAULT"
+
+
+def get_cache_manager(key) -> CacheManager:
+    import os
+
+    user_cache_manager = os.environ.get("TRITON_CACHE_MANAGER", None)
+    global __cache_cls
+    global __cache_cls_nme
+
+    if user_cache_manager is not None and user_cache_manager != __cache_cls_nme:
+        module_path, clz_nme = user_cache_manager.split(":")
+        module = importlib.import_module(module_path)
+        __cache_cls = getattr(module, clz_nme)
+        __cache_cls_nme = user_cache_manager
+
+    return __cache_cls(key)
+
+
+def get_override_manager(key) -> CacheManager:
+    return __cache_cls(key, override=True)
+
+
+def get_dump_manager(key) -> CacheManager:
+    return __cache_cls(key, dump=True)

shared/package-files/d0/d0ffb4973b6651de10e60155e16d7f39a3ead8da0aa3b1a5be6fb181122a8f7d/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0ffb4973b6651de10e60155e16d7f39a3ead8da0aa3b1a5be6fb181122a8f7d
+size 6846016

shared/package-files/d0/d0ffb73a5cb4d362844098a046ae382787c0e6482b7ca105ba896b3311730713/blob

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API _convert_indices_from_coo_to_csr {
+  using schema = at::Tensor (const at::Tensor &, int64_t, bool);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_convert_indices_from_coo_to_csr")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_convert_indices_from_coo_to_csr(Tensor self, int size, *, bool out_int32=False) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, int64_t size, bool out_int32);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t size, bool out_int32);
+};
+
+struct TORCH_API _convert_indices_from_coo_to_csr_out {
+  using schema = at::Tensor & (const at::Tensor &, int64_t, bool, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_convert_indices_from_coo_to_csr")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_convert_indices_from_coo_to_csr.out(Tensor self, int size, *, bool out_int32=False, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, int64_t size, bool out_int32, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t size, bool out_int32, at::Tensor & out);
+};
+
+}} // namespace at::_ops

shared/package-files/d1/d1077656f59bb84a73d5c477a4adafdd8761d037a58e4b5b9fed8f8dbb2275f9/blob

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1077656f59bb84a73d5c477a4adafdd8761d037a58e4b5b9fed8f8dbb2275f9
+size 1170754

shared/package-files/d1/d10ac70fd4d82a5499b8ef1dae75376d4149ad2bbcbf94a772ab6445258b8c63/blob

@@ -0,0 +1,108 @@
+"""
+This module implements a method to find
+Euler-Lagrange Equations for given Lagrangian.
+"""
+from itertools import combinations_with_replacement
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+def euler_equations(L, funcs=(), vars=()):
+    r"""
+    Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
+
+    Parameters
+    ==========
+
+    L : Expr
+        The Lagrangian that should be a function of the functions listed
+        in the second argument and their derivatives.
+
+        For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
+        two independent variables $x$, $y$ the Lagrangian has the form:
+
+            .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
+                      \frac{\partial f(x,y)}{\partial y},
+                      \frac{\partial g(x,y)}{\partial x},
+                      \frac{\partial g(x,y)}{\partial y},x,y\right)
+
+        In many cases it is not necessary to provide anything, except the
+        Lagrangian, it will be auto-detected (and an error raised if this
+        cannot be done).
+
+    funcs : Function or an iterable of Functions
+        The functions that the Lagrangian depends on. The Euler equations
+        are differential equations for each of these functions.
+
+    vars : Symbol or an iterable of Symbols
+        The Symbols that are the independent variables of the functions.
+
+    Returns
+    =======
+
+    eqns : list of Eq
+        The list of differential equations, one for each function.
+
+    Examples
+    ========
+
+    >>> from sympy import euler_equations, Symbol, Function
+    >>> x = Function('x')
+    >>> t = Symbol('t')
+    >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
+    >>> euler_equations(L, x(t), t)
+    [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
+    >>> u = Function('u')
+    >>> x = Symbol('x')
+    >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
+    >>> euler_equations(L, u(t, x), [t, x])
+    [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
+
+    """
+
+    funcs = tuple(funcs) if iterable(funcs) else (funcs,)
+
+    if not funcs:
+        funcs = tuple(L.atoms(Function))
+    else:
+        for f in funcs:
+            if not isinstance(f, Function):
+                raise TypeError('Function expected, got: %s' % f)
+
+    vars = tuple(vars) if iterable(vars) else (vars,)
+
+    if not vars:
+        vars = funcs[0].args
+    else:
+        vars = tuple(sympify(var) for var in vars)
+
+    if not all(isinstance(v, Symbol) for v in vars):
+        raise TypeError('Variables are not symbols, got %s' % vars)
+
+    for f in funcs:
+        if not vars == f.args:
+            raise ValueError("Variables %s do not match args: %s" % (vars, f))
+
+    order = max([len(d.variables) for d in L.atoms(Derivative)
+                        if d.expr in funcs] + [0])
+
+    eqns = []
+    for f in funcs:
+        eq = diff(L, f)
+        for i in range(1, order + 1):
+            for p in combinations_with_replacement(vars, i):
+                eq = eq + S.NegativeOne**i*diff(L, diff(f, *p), *p)
+        new_eq = Eq(eq, 0)
+        if isinstance(new_eq, Eq):
+            eqns.append(new_eq)
+
+    return eqns

shared/package-files/d1/d111625ea25c35f71d1fd8dc0dc06246e9cf756707667e00d1b95675247e32a1/blob

@@ -0,0 +1,380 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "arrow/chunked_array.h"  // IWYU pragma: keep
+#include "arrow/compare.h"
+#include "arrow/record_batch.h"
+#include "arrow/status.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+#include "arrow/util/macros.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow {
+
+class Array;
+class ChunkedArray;
+class KeyValueMetadata;
+class MemoryPool;
+
+/// \class Table
+/// \brief Logical table as sequence of chunked arrays
+class ARROW_EXPORT Table {
+ public:
+  virtual ~Table() = default;
+
+  /// \brief Construct a Table from schema and columns
+  ///
+  /// If columns is zero-length, the table's number of rows is zero
+  ///
+  /// \param[in] schema The table schema (column types)
+  /// \param[in] columns The table's columns as chunked arrays
+  /// \param[in] num_rows number of rows in table, -1 (default) to infer from columns
+  static std::shared_ptr<Table> Make(std::shared_ptr<Schema> schema,
+                                     std::vector<std::shared_ptr<ChunkedArray>> columns,
+                                     int64_t num_rows = -1);
+
+  /// \brief Construct a Table from schema and arrays
+  ///
+  /// \param[in] schema The table schema (column types)
+  /// \param[in] arrays The table's columns as arrays
+  /// \param[in] num_rows number of rows in table, -1 (default) to infer from columns
+  static std::shared_ptr<Table> Make(std::shared_ptr<Schema> schema,
+                                     const std::vector<std::shared_ptr<Array>>& arrays,
+                                     int64_t num_rows = -1);
+
+  /// \brief Create an empty Table of a given schema
+  ///
+  /// The output Table will be created with a single empty chunk per column.
+  ///
+  /// \param[in] schema the schema of the empty Table
+  /// \param[in] pool the memory pool to allocate memory from
+  /// \return the resulting Table
+  static Result<std::shared_ptr<Table>> MakeEmpty(
+      std::shared_ptr<Schema> schema, MemoryPool* pool = default_memory_pool());
+
+  /// \brief Construct a Table from a RecordBatchReader.
+  ///
+  /// \param[in] reader the arrow::RecordBatchReader that produces batches
+  static Result<std::shared_ptr<Table>> FromRecordBatchReader(RecordBatchReader* reader);
+
+  /// \brief Construct a Table from RecordBatches, using schema supplied by the first
+  /// RecordBatch.
+  ///
+  /// \param[in] batches a std::vector of record batches
+  static Result<std::shared_ptr<Table>> FromRecordBatches(
+      const std::vector<std::shared_ptr<RecordBatch>>& batches);
+
+  /// \brief Construct a Table from RecordBatches, using supplied schema. There may be
+  /// zero record batches
+  ///
+  /// \param[in] schema the arrow::Schema for each batch
+  /// \param[in] batches a std::vector of record batches
+  static Result<std::shared_ptr<Table>> FromRecordBatches(
+      std::shared_ptr<Schema> schema,
+      const std::vector<std::shared_ptr<RecordBatch>>& batches);
+
+  /// \brief Construct a Table from a chunked StructArray. One column will be produced
+  /// for each field of the StructArray.
+  ///
+  /// \param[in] array a chunked StructArray
+  static Result<std::shared_ptr<Table>> FromChunkedStructArray(
+      const std::shared_ptr<ChunkedArray>& array);
+
+  /// \brief Return the table schema
+  const std::shared_ptr<Schema>& schema() const { return schema_; }
+
+  /// \brief Return a column by index
+  virtual std::shared_ptr<ChunkedArray> column(int i) const = 0;
+
+  /// \brief Return vector of all columns for table
+  virtual const std::vector<std::shared_ptr<ChunkedArray>>& columns() const = 0;
+
+  /// Return a column's field by index
+  std::shared_ptr<Field> field(int i) const { return schema_->field(i); }
+
+  /// \brief Return vector of all fields for table
+  std::vector<std::shared_ptr<Field>> fields() const;
+
+  /// \brief Construct a zero-copy slice of the table with the
+  /// indicated offset and length
+  ///
+  /// \param[in] offset the index of the first row in the constructed
+  /// slice
+  /// \param[in] length the number of rows of the slice. If there are not enough
+  /// rows in the table, the length will be adjusted accordingly
+  ///
+  /// \return a new object wrapped in std::shared_ptr<Table>
+  virtual std::shared_ptr<Table> Slice(int64_t offset, int64_t length) const = 0;
+
+  /// \brief Slice from first row at offset until end of the table
+  std::shared_ptr<Table> Slice(int64_t offset) const { return Slice(offset, num_rows_); }
+
+  /// \brief Return a column by name
+  /// \param[in] name field name
+  /// \return an Array or null if no field was found
+  std::shared_ptr<ChunkedArray> GetColumnByName(const std::string& name) const {
+    auto i = schema_->GetFieldIndex(name);
+    return i == -1 ? NULLPTR : column(i);
+  }
+
+  /// \brief Remove column from the table, producing a new Table
+  virtual Result<std::shared_ptr<Table>> RemoveColumn(int i) const = 0;
+
+  /// \brief Add column to the table, producing a new Table
+  virtual Result<std::shared_ptr<Table>> AddColumn(
+      int i, std::shared_ptr<Field> field_arg,
+      std::shared_ptr<ChunkedArray> column) const = 0;
+
+  /// \brief Replace a column in the table, producing a new Table
+  virtual Result<std::shared_ptr<Table>> SetColumn(
+      int i, std::shared_ptr<Field> field_arg,
+      std::shared_ptr<ChunkedArray> column) const = 0;
+
+  /// \brief Return names of all columns
+  std::vector<std::string> ColumnNames() const;
+
+  /// \brief Rename columns with provided names
+  Result<std::shared_ptr<Table>> RenameColumns(
+      const std::vector<std::string>& names) const;
+
+  /// \brief Return new table with specified columns
+  Result<std::shared_ptr<Table>> SelectColumns(const std::vector<int>& indices) const;
+
+  /// \brief Replace schema key-value metadata with new metadata
+  /// \since 0.5.0
+  ///
+  /// \param[in] metadata new KeyValueMetadata
+  /// \return new Table
+  virtual std::shared_ptr<Table> ReplaceSchemaMetadata(
+      const std::shared_ptr<const KeyValueMetadata>& metadata) const = 0;
+
+  /// \brief Flatten the table, producing a new Table.  Any column with a
+  /// struct type will be flattened into multiple columns
+  ///
+  /// \param[in] pool The pool for buffer allocations, if any
+  virtual Result<std::shared_ptr<Table>> Flatten(
+      MemoryPool* pool = default_memory_pool()) const = 0;
+
+  /// \return PrettyPrint representation suitable for debugging
+  std::string ToString() const;
+
+  /// \brief Perform cheap validation checks to determine obvious inconsistencies
+  /// within the table's schema and internal data.
+  ///
+  /// This is O(k*m) where k is the total number of field descendents,
+  /// and m is the number of chunks.
+  ///
+  /// \return Status
+  virtual Status Validate() const = 0;
+
+  /// \brief Perform extensive validation checks to determine inconsistencies
+  /// within the table's schema and internal data.
+  ///
+  /// This is O(k*n) where k is the total number of field descendents,
+  /// and n is the number of rows.
+  ///
+  /// \return Status
+  virtual Status ValidateFull() const = 0;
+
+  /// \brief Return the number of columns in the table
+  int num_columns() const { return schema_->num_fields(); }
+
+  /// \brief Return the number of rows (equal to each column's logical length)
+  int64_t num_rows() const { return num_rows_; }
+
+  /// \brief Determine if two tables are equal
+  ///
+  /// \param[in] other the table to compare with
+  /// \param[in] opts the options for equality comparisons
+  /// \return true if two tables are equal
+  bool Equals(const Table& other, const EqualOptions& opts) const;
+
+  /// \brief Determine if two tables are equal
+  ///
+  /// \param[in] other the table to compare with
+  /// \param[in] check_metadata if true, the schema metadata will be compared,
+  ///            regardless of the value set in \ref EqualOptions::use_metadata
+  /// \param[in] opts the options for equality comparisons
+  /// \return true if two tables are equal
+  bool Equals(const Table& other, bool check_metadata = false,
+              const EqualOptions& opts = EqualOptions::Defaults()) const {
+    return Equals(other, opts.use_metadata(check_metadata));
+  }
+
+  /// \brief Make a new table by combining the chunks this table has.
+  ///
+  /// All the underlying chunks in the ChunkedArray of each column are
+  /// concatenated into zero or one chunk.
+  ///
+  /// To avoid buffer overflow, binary columns may be combined into
+  /// multiple chunks. Chunks will have the maximum possible length.
+  ///
+  /// \param[in] pool The pool for buffer allocations
+  Result<std::shared_ptr<Table>> CombineChunks(
+      MemoryPool* pool = default_memory_pool()) const;
+
+  /// \brief Make a new record batch by combining the chunks this table has.
+  ///
+  /// All the underlying chunks in the ChunkedArray of each column are
+  /// concatenated into a single chunk.
+  ///
+  /// \param[in] pool The pool for buffer allocations
+  Result<std::shared_ptr<RecordBatch>> CombineChunksToBatch(
+      MemoryPool* pool = default_memory_pool()) const;
+
+ protected:
+  Table();
+
+  std::shared_ptr<Schema> schema_;
+  int64_t num_rows_;
+
+ private:
+  ARROW_DISALLOW_COPY_AND_ASSIGN(Table);
+};
+
+/// \brief Compute a stream of record batches from a (possibly chunked) Table
+///
+/// The conversion is zero-copy: each record batch is a view over a slice
+/// of the table's columns.
+///
+/// The table is expected to be valid prior to using it with the batch reader.
+class ARROW_EXPORT TableBatchReader : public RecordBatchReader {
+ public:
+  /// \brief Construct a TableBatchReader for the given table
+  explicit TableBatchReader(const Table& table);
+  explicit TableBatchReader(std::shared_ptr<Table> table);
+
+  std::shared_ptr<Schema> schema() const override;
+
+  Status ReadNext(std::shared_ptr<RecordBatch>* out) override;
+
+  /// \brief Set the desired maximum number of rows for record batches
+  ///
+  /// The actual number of rows in each record batch may be smaller, depending
+  /// on actual chunking characteristics of each table column.
+  void set_chunksize(int64_t chunksize);
+
+ private:
+  std::shared_ptr<Table> owned_table_;
+  const Table& table_;
+  std::vector<ChunkedArray*> column_data_;
+  std::vector<int> chunk_numbers_;
+  std::vector<int64_t> chunk_offsets_;
+  int64_t absolute_row_position_;
+  int64_t max_chunksize_;
+};
+
+/// \brief Controls the behavior of ConcatenateTables().
+struct ARROW_EXPORT ConcatenateTablesOptions {
+  /// If true, the schemas of the tables will be first unified with fields of
+  /// the same name being merged, according to `field_merge_options`, then each
+  /// table will be promoted to the unified schema before being concatenated.
+  /// Otherwise, all tables should have the same schema. Each column in the output table
+  /// is the result of concatenating the corresponding columns in all input tables.
+  bool unify_schemas = false;
+
+  /// options to control how fields are merged when unifying schemas
+  ///
+  /// This field will be ignored if unify_schemas is false
+  Field::MergeOptions field_merge_options = Field::MergeOptions::Defaults();
+
+  static ConcatenateTablesOptions Defaults() { return {}; }
+};
+
+/// \brief Construct a new table from multiple input tables.
+///
+/// The new table is assembled from existing column chunks without copying,
+/// if schemas are identical. If schemas do not match exactly and
+/// unify_schemas is enabled in options (off by default), an attempt is
+/// made to unify them, and then column chunks are converted to their
+/// respective unified datatype, which will probably incur a copy.
+/// :func:`arrow::PromoteTableToSchema` is used to unify schemas.
+///
+/// Tables are concatenated in order they are provided in and the order of
+/// rows within tables will be preserved.
+///
+/// \param[in] tables a std::vector of Tables to be concatenated
+/// \param[in] options specify how to unify schema of input tables
+/// \param[in] memory_pool MemoryPool to be used if null-filled arrays need to
+/// be created or if existing column chunks need to endure type conversion
+/// \return new Table
+ARROW_EXPORT
+Result<std::shared_ptr<Table>> ConcatenateTables(
+    const std::vector<std::shared_ptr<Table>>& tables,
+    ConcatenateTablesOptions options = ConcatenateTablesOptions::Defaults(),
+    MemoryPool* memory_pool = default_memory_pool());
+
+namespace compute {
+class CastOptions;
+}
+
+/// \brief Promotes a table to conform to the given schema.
+///
+/// If a field in the schema does not have a corresponding column in
+/// the table, a column of nulls will be added to the resulting table.
+/// If the corresponding column is of type Null, it will be promoted
+/// to the type specified by schema, with null values filled. The
+/// column will be casted to the type specified by the schema.
+///
+/// Returns an error:
+/// - if the corresponding column's type is not compatible with the
+///   schema.
+/// - if there is a column in the table that does not exist in the schema.
+/// - if the cast fails or casting would be required but is not available.
+///
+/// \param[in] table the input Table
+/// \param[in] schema the target schema to promote to
+/// \param[in] pool The memory pool to be used if null-filled arrays need to
+/// be created.
+ARROW_EXPORT
+Result<std::shared_ptr<Table>> PromoteTableToSchema(
+    const std::shared_ptr<Table>& table, const std::shared_ptr<Schema>& schema,
+    MemoryPool* pool = default_memory_pool());
+
+/// \brief Promotes a table to conform to the given schema.
+///
+/// If a field in the schema does not have a corresponding column in
+/// the table, a column of nulls will be added to the resulting table.
+/// If the corresponding column is of type Null, it will be promoted
+/// to the type specified by schema, with null values filled. The column
+/// will be casted to the type specified by the schema.
+///
+/// Returns an error:
+/// - if the corresponding column's type is not compatible with the
+///   schema.
+/// - if there is a column in the table that does not exist in the schema.
+/// - if the cast fails or casting would be required but is not available.
+///
+/// \param[in] table the input Table
+/// \param[in] schema the target schema to promote to
+/// \param[in] options The cast options to allow promotion of types
+/// \param[in] pool The memory pool to be used if null-filled arrays need to
+/// be created.
+ARROW_EXPORT
+Result<std::shared_ptr<Table>> PromoteTableToSchema(
+    const std::shared_ptr<Table>& table, const std::shared_ptr<Schema>& schema,
+    const compute::CastOptions& options, MemoryPool* pool = default_memory_pool());
+
+}  // namespace arrow

shared/package-files/d1/d1119423dda95126d93a1095b189e7832c14d70332dcdd2d0af063f26349bbdf/blob

@@ -0,0 +1,22 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor fbgemm_pack_quantized_matrix(const at::Tensor & input);
+TORCH_API at::Tensor fbgemm_pack_quantized_matrix(const at::Tensor & input, int64_t K, int64_t N);
+} // namespace native
+} // namespace at

shared/package-files/d1/d11309bf78977fd3a500c085e1a201e0fca9e009e8294baa0bfb58fb235019b2/blob

@@ -0,0 +1,73 @@
+import unittest
+
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+from numba.tests.support import captured_stdout
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestVecAdd(CUDATestCase):
+    """
+    Test simple vector addition
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing
+        # up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_vecadd(self):
+        # ex_vecadd.import.begin
+        import numpy as np
+        from numba import cuda
+        # ex_vecadd.import.end
+
+        # ex_vecadd.kernel.begin
+        @cuda.jit
+        def f(a, b, c):
+            # like threadIdx.x + (blockIdx.x * blockDim.x)
+            tid = cuda.grid(1)
+            size = len(c)
+
+            if tid < size:
+                c[tid] = a[tid] + b[tid]
+        # ex_vecadd.kernel.end
+
+        # Seed RNG for test repeatability
+        np.random.seed(1)
+
+        # ex_vecadd.allocate.begin
+        N = 100000
+        a = cuda.to_device(np.random.random(N))
+        b = cuda.to_device(np.random.random(N))
+        c = cuda.device_array_like(a)
+        # ex_vecadd.allocate.end
+
+        # ex_vecadd.forall.begin
+        f.forall(len(a))(a, b, c)
+        print(c.copy_to_host())
+        # ex_vecadd.forall.end
+
+        # ex_vecadd.launch.begin
+        # Enough threads per block for several warps per block
+        nthreads = 256
+        # Enough blocks to cover the entire vector depending on its length
+        nblocks = (len(a) // nthreads) + 1
+        f[nblocks, nthreads](a, b, c)
+        print(c.copy_to_host())
+        # ex_vecadd.launch.end
+
+        np.testing.assert_equal(
+            c.copy_to_host(),
+            a.copy_to_host() + b.copy_to_host()
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

shared/package-files/d1/d115718818e3e3367847ce35bb5ff0361d08993d9749d438c918f8eb87ad8814/blob

@@ -0,0 +1,27 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset mt DAYS_OF_WEEK_ABBREV [list \
+        "\u0126ad"\
+        "Tne"\
+        "Tli"\
+        "Erb"\
+        "\u0126am"\
+        "\u0120im"]
+    ::msgcat::mcset mt MONTHS_ABBREV [list \
+        "Jan"\
+        "Fra"\
+        "Mar"\
+        "Apr"\
+        "Mej"\
+        "\u0120un"\
+        "Lul"\
+        "Awi"\
+        "Set"\
+        "Ott"\
+        "Nov"]
+    ::msgcat::mcset mt BCE "QK"
+    ::msgcat::mcset mt CE ""
+    ::msgcat::mcset mt DATE_FORMAT "%A, %e ta %B, %Y"
+    ::msgcat::mcset mt TIME_FORMAT_12 "%l:%M:%S %P"
+    ::msgcat::mcset mt DATE_TIME_FORMAT "%A, %e ta %B, %Y %l:%M:%S %P %z"
+}

shared/package-files/d1/d119859b1979b8decbc7beb0ac5349d90cade35b2e593dc7a9e7f4eb7b22c681/blob

@@ -0,0 +1,2068 @@
+import copy
+import operator
+
+import types as pytypes
+import operator
+import warnings
+from dataclasses import make_dataclass
+
+import llvmlite.ir
+import numpy as np
+
+import numba
+from numba.parfors import parfor
+from numba.core import types, ir, config, compiler, sigutils, cgutils
+from numba.core.ir_utils import (
+    add_offset_to_labels,
+    replace_var_names,
+    remove_dels,
+    legalize_names,
+    rename_labels,
+    get_name_var_table,
+    visit_vars_inner,
+    get_definition,
+    guard,
+    get_call_table,
+    is_pure,
+    get_np_ufunc_typ,
+    get_unused_var_name,
+    is_const_call,
+    fixup_var_define_in_scope,
+    transfer_scope,
+    find_max_label,
+    get_global_func_typ,
+    find_topo_order,
+)
+from numba.core.typing import signature
+from numba.core import lowering
+from numba.parfors.parfor import ensure_parallel_support
+from numba.core.errors import (
+    NumbaParallelSafetyWarning, NotDefinedError, CompilerError, InternalError,
+)
+from numba.parfors.parfor_lowering_utils import ParforLoweringBuilder
+
+
+class ParforLower(lowering.Lower):
+    """This is a custom lowering class that extends standard lowering so as
+    to accommodate parfor.Parfor nodes."""
+
+    # custom instruction lowering to handle parfor nodes
+    def lower_inst(self, inst):
+        if isinstance(inst, parfor.Parfor):
+            _lower_parfor_parallel(self, inst)
+        else:
+            super().lower_inst(inst)
+
+    @property
+    def _disable_sroa_like_opt(self):
+        """
+        Force disable this because Parfor use-defs is incompatible---it only
+        considers use-defs in blocks that must be executing.
+        See https://github.com/numba/numba/commit/017e2ff9db87fc34149b49dd5367ecbf0bb45268
+        """
+        return True
+
+
+def _lower_parfor_parallel(lowerer, parfor):
+    if parfor.lowerer is None:
+        return _lower_parfor_parallel_std(lowerer, parfor)
+    else:
+        return parfor.lowerer(lowerer, parfor)
+
+
+def _lower_parfor_parallel_std(lowerer, parfor):
+    """Lowerer that handles LLVM code generation for parfor.
+    This function lowers a parfor IR node to LLVM.
+    The general approach is as follows:
+    1) The code from the parfor's init block is lowered normally
+       in the context of the current function.
+    2) The body of the parfor is transformed into a gufunc function.
+    3) Code is inserted into the main function that calls do_scheduling
+       to divide the iteration space for each thread, allocates
+       reduction arrays, calls the gufunc function, and then invokes
+       the reduction function across the reduction arrays to produce
+       the final reduction values.
+    """
+    from numba.np.ufunc.parallel import get_thread_count
+
+    ensure_parallel_support()
+    typingctx = lowerer.context.typing_context
+    targetctx = lowerer.context
+    builder = lowerer.builder
+    # We copy the typemap here because for race condition variable we'll
+    # update their type to array so they can be updated by the gufunc.
+    orig_typemap = lowerer.fndesc.typemap
+    # replace original typemap with copy and restore the original at the end.
+    lowerer.fndesc.typemap = copy.copy(orig_typemap)
+    if config.DEBUG_ARRAY_OPT:
+        print("lowerer.fndesc", lowerer.fndesc, type(lowerer.fndesc))
+    typemap = lowerer.fndesc.typemap
+    varmap = lowerer.varmap
+
+    if config.DEBUG_ARRAY_OPT:
+        print("_lower_parfor_parallel")
+        parfor.dump()
+
+    loc = parfor.init_block.loc
+    scope = parfor.init_block.scope
+
+    # produce instructions for init_block
+    if config.DEBUG_ARRAY_OPT:
+        print("init_block = ", parfor.init_block, " ", type(parfor.init_block))
+    for instr in parfor.init_block.body:
+        if config.DEBUG_ARRAY_OPT:
+            print("lower init_block instr = ", instr)
+        lowerer.lower_inst(instr)
+
+    for racevar in parfor.races:
+        if racevar not in varmap:
+            rvtyp = typemap[racevar]
+            rv = ir.Var(scope, racevar, loc)
+            lowerer._alloca_var(rv.name, rvtyp)
+
+    alias_map = {}
+    arg_aliases = {}
+    numba.parfors.parfor.find_potential_aliases_parfor(parfor, parfor.params, typemap,
+                                        lowerer.func_ir, alias_map, arg_aliases)
+    if config.DEBUG_ARRAY_OPT:
+        print("alias_map", alias_map)
+        print("arg_aliases", arg_aliases)
+
+    # run get_parfor_outputs() and get_parfor_reductions() before gufunc creation
+    # since Jumps are modified so CFG of loop_body dict will become invalid
+    assert parfor.params is not None
+
+    parfor_output_arrays = numba.parfors.parfor.get_parfor_outputs(
+        parfor, parfor.params)
+    parfor_redvars, parfor_reddict = parfor.redvars, parfor.reddict
+    if config.DEBUG_ARRAY_OPT:
+        print("parfor_redvars:", parfor_redvars)
+        print("parfor_reddict:", parfor_reddict)
+
+    # init reduction array allocation here.
+    nredvars = len(parfor_redvars)
+    redarrs = {}
+    to_cleanup = []
+    if nredvars > 0:
+        # reduction arrays outer dimension equal to thread count
+        scope = parfor.init_block.scope
+        loc = parfor.init_block.loc
+        pfbdr = ParforLoweringBuilder(lowerer=lowerer, scope=scope, loc=loc)
+
+        # Get the Numba internal function to call to get the thread count.
+        get_num_threads = pfbdr.bind_global_function(
+            fobj=numba.np.ufunc.parallel._iget_num_threads,
+            ftype=get_global_func_typ(numba.np.ufunc.parallel._iget_num_threads),
+            args=()
+        )
+
+        # Insert the call to assign the thread count to a variable.
+        num_threads_var = pfbdr.assign(
+            rhs=pfbdr.call(get_num_threads, args=[]),
+            typ=types.intp,
+            name="num_threads_var")
+
+        # For each reduction variable...
+        for i in range(nredvars):
+            red_name = parfor_redvars[i]
+            # Get the type of the reduction variable.
+            redvar_typ = lowerer.fndesc.typemap[red_name]
+            # Get the ir.Var for the reduction variable.
+            redvar = ir.Var(scope, red_name, loc)
+            # Get the type of the array that holds the per-thread
+            # reduction variables.
+            redarrvar_typ = redtyp_to_redarraytype(redvar_typ)
+            reddtype = redarrvar_typ.dtype
+            if config.DEBUG_ARRAY_OPT:
+                print(
+                    "reduction_info",
+                    red_name,
+                    redvar_typ,
+                    redarrvar_typ,
+                    reddtype,
+                    types.DType(reddtype),
+                    num_threads_var,
+                    type(num_threads_var)
+                )
+
+            # If this is reduction over an array,
+            # the reduction array has just one added per-worker dimension.
+            if isinstance(redvar_typ, types.npytypes.Array):
+                redarrdim = redvar_typ.ndim + 1
+            else:
+                redarrdim = 1
+
+            # Reduction array is created and initialized to the initial reduction value.
+
+            # First create a var for the numpy empty ufunc.
+            glbl_np_empty = pfbdr.bind_global_function(
+                fobj=np.empty,
+                ftype=get_np_ufunc_typ(np.empty, pfbdr._typingctx),
+                args=(
+                    types.UniTuple(types.intp, redarrdim),
+                ),
+                kws={'dtype': types.DType(reddtype)}
+            )
+
+            size_var_list = [num_threads_var]
+
+            # If this is a reduction over an array...
+            if isinstance(redvar_typ, types.npytypes.Array):
+                # Add code to get the shape of the array being reduced over.
+                redshape_var = pfbdr.assign(
+                    rhs=ir.Expr.getattr(redvar, "shape", loc),
+                    typ=types.UniTuple(types.intp, redvar_typ.ndim),
+                    name="redarr_shape",
+                )
+
+                # Add the dimension sizes of the array being reduced over to the tuple of sizes pass to empty.
+                for j in range(redvar_typ.ndim):
+                    onedimvar = pfbdr.assign(
+                        rhs=ir.Expr.static_getitem(redshape_var, j, None, loc),
+                        typ=types.intp,
+                        name="redshapeonedim",
+                    )
+                    size_var_list.append(onedimvar)
+
+            # Empty call takes tuple of sizes.  Create here and fill in outer dimension (num threads).
+            size_var = pfbdr.make_tuple_variable(
+                size_var_list, name='tuple_size_var',
+            )
+
+            # Resolve dtype
+            cval = pfbdr._typingctx.resolve_value_type(reddtype)
+            dt = pfbdr.make_const_variable(cval=cval, typ=types.DType(reddtype))
+            # Add call to empty passing the size var tuple.
+            empty_call = pfbdr.call(glbl_np_empty, args=[size_var, dt])
+
+            redarr_var = pfbdr.assign(
+                rhs=empty_call, typ=redarrvar_typ, name="redarr",
+            )
+
+            # Remember mapping of original reduction array to the newly created per-worker reduction array.
+            redarrs[redvar.name] = redarr_var
+            to_cleanup.append(redarr_var)
+
+            init_val = parfor_reddict[red_name].init_val
+
+            if init_val is not None:
+                if isinstance(redvar_typ, types.npytypes.Array):
+                    # Create an array of identity values for the reduction.
+                    # First, create a variable for np.full.
+                    full_func_node = pfbdr.bind_global_function(
+                        fobj=np.full,
+                        ftype=get_np_ufunc_typ(np.full, pfbdr._typingctx),
+                        args=(
+                            types.UniTuple(types.intp, redvar_typ.ndim),
+                            reddtype,
+                        ),
+                        kws={'dtype': types.DType(reddtype)},
+                    )
+
+                    # Then create a var with the identify value.
+                    init_val_var = pfbdr.make_const_variable(
+                        cval=init_val,
+                        typ=reddtype,
+                        name="init_val",
+                    )
+
+                    # Then, call np.full with the shape of the reduction array and the identity value.
+                    full_call = pfbdr.call(
+                        full_func_node, args=[redshape_var, init_val_var, dt],
+                    )
+
+                    redtoset = pfbdr.assign(
+                        rhs=full_call,
+                        typ=redvar_typ,
+                        name="redtoset",
+                    )
+                    # rettoset is an array from np.full() and must be released
+                    to_cleanup.append(redtoset)
+                else:
+                    redtoset = pfbdr.make_const_variable(
+                        cval=init_val,
+                        typ=reddtype,
+                        name="redtoset",
+                    )
+            else:
+                redtoset = redvar
+
+                if config.DEBUG_ARRAY_OPT_RUNTIME:
+                    res_print_str = "res_print1 for redvar " + str(redvar) + ":"
+                    strconsttyp = types.StringLiteral(res_print_str)
+
+                    lhs = pfbdr.make_const_variable(
+                        cval=res_print_str,
+                        typ=strconsttyp,
+                        name="str_const",
+                    )
+
+                    res_print = ir.Print(args=[lhs, redvar],
+                                         vararg=None, loc=loc)
+                    lowerer.fndesc.calltypes[res_print] = signature(types.none,
+                                                             typemap[lhs.name],
+                                                             typemap[redvar.name])
+                    print("res_print_redvar", res_print)
+                    lowerer.lower_inst(res_print)
+
+
+            # For each thread, initialize the per-worker reduction array to
+            # the current reduction array value.
+
+            # Get the Numba type of the variable that holds the thread count.
+            num_thread_type = typemap[num_threads_var.name]
+            # Get the LLVM type of the thread count variable.
+            ntllvm_type = targetctx.get_value_type(num_thread_type)
+            # Create a LLVM variable to hold the loop index.
+            alloc_loop_var = cgutils.alloca_once(builder, ntllvm_type)
+            # Associate this LLVM variable to a Numba IR variable so that
+            # we can use setitem IR builder.
+            # Create a Numba IR variable.
+            numba_ir_loop_index_var = scope.redefine("$loop_index", loc)
+            # Give that variable the right type.
+            typemap[numba_ir_loop_index_var.name] = num_thread_type
+            # Associate this Numba variable to the LLVM variable in the
+            # lowerer's varmap.
+            lowerer.varmap[numba_ir_loop_index_var.name] = alloc_loop_var
+            # Insert a loop into the outputed LLVM that goes from 0 to
+            # the current thread count.
+            with cgutils.for_range(builder, lowerer.loadvar(num_threads_var.name), intp=ntllvm_type) as loop:
+                # Store the loop index into the alloca'd LLVM loop index variable.
+                builder.store(loop.index, alloc_loop_var)
+                # Initialize one element of the reduction array using the Numba
+                # IR variable associated with this loop's index.
+                pfbdr.setitem(obj=redarr_var, index=numba_ir_loop_index_var, val=redtoset)
+
+    # compile parfor body as a separate function to be used with GUFuncWrapper
+    flags = parfor.flags.copy()
+    flags.error_model = "numpy"
+    # Can't get here unless  flags.auto_parallel == ParallelOptions(True)
+    index_var_typ = typemap[parfor.loop_nests[0].index_variable.name]
+    # index variables should have the same type, check rest of indices
+    for l in parfor.loop_nests[1:]:
+        assert typemap[l.index_variable.name] == index_var_typ
+    numba.parfors.parfor.sequential_parfor_lowering = True
+    try:
+        (func,
+         func_args,
+         func_sig,
+         func_arg_types,
+         exp_name_to_tuple_var) = _create_gufunc_for_parfor_body(
+            lowerer, parfor, typemap, typingctx, targetctx, flags, {},
+            bool(alias_map), index_var_typ, parfor.races)
+    finally:
+        numba.parfors.parfor.sequential_parfor_lowering = False
+
+    # get the shape signature
+    func_args = ['sched'] + func_args
+    num_reductions = len(parfor_redvars)
+    num_inputs = len(func_args) - len(parfor_output_arrays) - num_reductions
+    if config.DEBUG_ARRAY_OPT:
+        print("func_args = ", func_args)
+        print("num_inputs = ", num_inputs)
+        print("parfor_outputs = ", parfor_output_arrays)
+        print("parfor_redvars = ", parfor_redvars)
+        print("num_reductions = ", num_reductions)
+    gu_signature = _create_shape_signature(
+        parfor.get_shape_classes,
+        num_inputs,
+        num_reductions,
+        func_args,
+        func_sig,
+        parfor.races,
+        typemap)
+    if config.DEBUG_ARRAY_OPT:
+        print("gu_signature = ", gu_signature)
+
+    # call the func in parallel by wrapping it with ParallelGUFuncBuilder
+    loop_ranges = [(l.start, l.stop, l.step) for l in parfor.loop_nests]
+    if config.DEBUG_ARRAY_OPT:
+        print("loop_nests = ", parfor.loop_nests)
+        print("loop_ranges = ", loop_ranges)
+    call_parallel_gufunc(
+        lowerer,
+        func,
+        gu_signature,
+        func_sig,
+        func_args,
+        func_arg_types,
+        loop_ranges,
+        parfor_redvars,
+        parfor_reddict,
+        redarrs,
+        parfor.init_block,
+        index_var_typ,
+        parfor.races,
+        exp_name_to_tuple_var)
+
+    if nredvars > 0:
+        _parfor_lowering_finalize_reduction(
+            parfor, redarrs, lowerer, parfor_reddict, num_threads_var,
+        )
+
+    # Cleanup reduction variable
+    for v in to_cleanup:
+        lowerer.lower_inst(ir.Del(v.name, loc=loc))
+    # Restore the original typemap of the function that was replaced temporarily at the
+    # Beginning of this function.
+    lowerer.fndesc.typemap = orig_typemap
+
+    if config.DEBUG_ARRAY_OPT:
+        print("_lower_parfor_parallel done")
+
+
+_ReductionInfo = make_dataclass(
+    "_ReductionInfo",
+    [
+        "redvar_info",
+        "redvar_name",
+        "redvar_typ",
+        "redarr_var",
+        "redarr_typ",
+        "init_val",
+    ],
+    frozen=True,
+)
+
+
+def _parfor_lowering_finalize_reduction(
+        parfor,
+        redarrs,
+        lowerer,
+        parfor_reddict,
+        thread_count_var,
+    ):
+    """Emit code to finalize the reduction from the intermediate values of
+    each thread.
+    """
+    # For each reduction variable
+    for redvar_name, redarr_var in redarrs.items():
+        # Pseudo-code for this loop body:
+        #     tmp = redarr[0]
+        #     for i in range(1, thread_count):
+        #         tmp = reduce_op(redarr[i], tmp)
+        #     reduction_result = tmp
+        redvar_typ = lowerer.fndesc.typemap[redvar_name]
+        redarr_typ = lowerer.fndesc.typemap[redarr_var.name]
+        init_val = lowerer.loadvar(redvar_name)
+
+        reduce_info = _ReductionInfo(
+            redvar_info = parfor_reddict[redvar_name],
+            redvar_name=redvar_name,
+            redvar_typ=redvar_typ,
+            redarr_var=redarr_var,
+            redarr_typ=redarr_typ,
+            init_val=init_val,
+        )
+        # generate code for combining reduction variable with thread output
+        handler = (_lower_trivial_inplace_binops
+                   if reduce_info.redvar_info.redop is not None
+                   else _lower_non_trivial_reduce)
+        handler(parfor, lowerer, thread_count_var, reduce_info)
+
+
+class ParforsUnexpectedReduceNodeError(InternalError):
+    def __init__(self, inst):
+        super().__init__(f"Unknown reduce instruction node: {inst}")
+
+
+def _lower_trivial_inplace_binops(parfor, lowerer, thread_count_var, reduce_info):
+    """Lower trivial inplace-binop reduction.
+    """
+    for inst in reduce_info.redvar_info.reduce_nodes:
+        # Var assigns to Var?
+        if _lower_var_to_var_assign(lowerer, inst):
+            pass
+        # Is inplace-binop for the reduction?
+        elif _is_right_op_and_rhs_is_init(inst, reduce_info.redvar_name, "inplace_binop"):
+            fn = inst.value.fn
+            redvar_result = _emit_binop_reduce_call(
+                fn, lowerer, thread_count_var, reduce_info,
+            )
+            lowerer.storevar(redvar_result, name=inst.target.name)
+        # Is binop for the reduction?
+        elif _is_right_op_and_rhs_is_init(inst, reduce_info.redvar_name, "binop"):
+            fn = inst.value.fn
+            redvar_result = _emit_binop_reduce_call(
+                fn, lowerer, thread_count_var, reduce_info,
+            )
+            lowerer.storevar(redvar_result, name=inst.target.name)
+        # Otherwise?
+        else:
+            raise ParforsUnexpectedReduceNodeError(inst)
+
+        # XXX: This seems like a hack to stop the loop with this condition.
+        if _fix_redvar_name_ssa_mismatch(parfor, lowerer, inst,
+                                   reduce_info.redvar_name):
+            break
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        varname = reduce_info.redvar_name
+        lowerer.print_variable(
+            f"{parfor.loc}: parfor {fn.__name__} reduction {varname} =",
+            varname,
+        )
+
+
+def _lower_non_trivial_reduce(parfor, lowerer, thread_count_var, reduce_info):
+    """Lower non-trivial reduction such as call to `functools.reduce()`.
+    """
+    init_name = f"{reduce_info.redvar_name}#init"
+    # The init_name variable is not defined at this point.
+    lowerer.fndesc.typemap.setdefault(init_name, reduce_info.redvar_typ)
+    # Emit a sequence of the reduction operation for each intermediate result
+    # of each thread.
+    num_thread_llval = lowerer.loadvar(thread_count_var.name)
+    with cgutils.for_range(lowerer.builder, num_thread_llval) as loop:
+        tid = loop.index
+        for inst in reduce_info.redvar_info.reduce_nodes:
+            # Var assigns to Var?
+            if _lower_var_to_var_assign(lowerer, inst):
+                pass
+            # The reduction operation?
+            elif (isinstance(inst, ir.Assign)
+                    and any(var.name == init_name for var in inst.list_vars())):
+                elem = _emit_getitem_call(tid, lowerer, reduce_info)
+                lowerer.storevar(elem, init_name)
+                lowerer.lower_inst(inst)
+
+            # Otherwise?
+            else:
+                raise ParforsUnexpectedReduceNodeError(inst)
+
+            # XXX: This seems like a hack to stop the loop with this condition.
+            if _fix_redvar_name_ssa_mismatch(parfor, lowerer, inst,
+                                       reduce_info.redvar_name):
+                break
+
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        varname = reduce_info.redvar_name
+        lowerer.print_variable(
+            f"{parfor.loc}: parfor non-trivial reduction {varname} =",
+            varname,
+        )
+
+def _lower_var_to_var_assign(lowerer, inst):
+    """Lower Var->Var assignment.
+
+    Returns True if-and-only-if `inst` is a Var->Var assignment.
+    """
+    if isinstance(inst, ir.Assign) and isinstance(inst.value, ir.Var):
+        loaded = lowerer.loadvar(inst.value.name)
+        lowerer.storevar(loaded, name=inst.target.name)
+        return True
+    return False
+
+def _emit_getitem_call(idx, lowerer, reduce_info):
+    """Emit call to ``redarr_var[idx]``
+    """
+    def reducer_getitem(redarr, index):
+        return redarr[index]
+
+    builder = lowerer.builder
+    ctx = lowerer.context
+    redarr_typ = reduce_info.redarr_typ
+    arg_arr = lowerer.loadvar(reduce_info.redarr_var.name)
+    args = (arg_arr, idx)
+    sig = signature(reduce_info.redvar_typ, redarr_typ, types.intp)
+    elem = ctx.compile_internal(builder, reducer_getitem, sig, args)
+    return elem
+
+
+def _emit_binop_reduce_call(binop, lowerer, thread_count_var, reduce_info):
+    """Emit call to the ``binop`` for the reduction variable.
+    """
+
+    def reduction_add(thread_count, redarr, init):
+        c = init
+        for i in range(thread_count):
+            c += redarr[i]
+        return c
+
+    def reduction_mul(thread_count, redarr, init):
+        c = init
+        for i in range(thread_count):
+            c *= redarr[i]
+        return c
+
+    kernel = {
+        operator.iadd: reduction_add,
+        operator.isub: reduction_add,
+        operator.add: reduction_add,
+        operator.sub: reduction_add,
+        operator.imul: reduction_mul,
+        operator.ifloordiv: reduction_mul,
+        operator.itruediv: reduction_mul,
+        operator.mul: reduction_mul,
+        operator.floordiv: reduction_mul,
+        operator.truediv: reduction_mul,
+    }[binop]
+
+    ctx = lowerer.context
+    builder = lowerer.builder
+    redarr_typ = reduce_info.redarr_typ
+    arg_arr = lowerer.loadvar(reduce_info.redarr_var.name)
+
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        init_var = reduce_info.redarr_var.scope.get(reduce_info.redvar_name)
+        res_print = ir.Print(
+            args=[reduce_info.redarr_var, init_var], vararg=None,
+            loc=lowerer.loc,
+        )
+        typemap = lowerer.fndesc.typemap
+        lowerer.fndesc.calltypes[res_print] = signature(
+            types.none, typemap[reduce_info.redarr_var.name],
+            typemap[init_var.name],
+        )
+        lowerer.lower_inst(res_print)
+
+    arg_thread_count = lowerer.loadvar(thread_count_var.name)
+    args = (arg_thread_count, arg_arr, reduce_info.init_val)
+    sig = signature(
+        reduce_info.redvar_typ, types.uintp, redarr_typ, reduce_info.redvar_typ,
+    )
+
+    redvar_result = ctx.compile_internal(builder, kernel, sig, args)
+    return redvar_result
+
+
+def _is_right_op_and_rhs_is_init(inst, redvar_name, op):
+    """Is ``inst`` an inplace-binop and the RHS is the reduction init?
+    """
+    if not isinstance(inst, ir.Assign):
+        return False
+    rhs = inst.value
+    if not isinstance(rhs, ir.Expr):
+        return False
+    if rhs.op != op:
+        return False
+    if rhs.rhs.name != f"{redvar_name}#init":
+        return False
+    return True
+
+
+def _fix_redvar_name_ssa_mismatch(parfor, lowerer, inst, redvar_name):
+    """Fix reduction variable name mismatch due to SSA.
+    """
+    # Only process reduction statements post-gufunc execution
+    # until we see an assignment with a left-hand side to the
+    # reduction variable's name.  This fixes problems with
+    # cases where there are multiple assignments to the
+    # reduction variable in the parfor.
+    scope = parfor.init_block.scope
+    if isinstance(inst, ir.Assign):
+        try:
+            reduction_var = scope.get_exact(redvar_name)
+        except NotDefinedError:
+            # Ideally, this shouldn't happen. The redvar name
+            # missing from scope indicates an error from
+            # other rewrite passes.
+            is_same_source_var = redvar_name == inst.target.name
+        else:
+            # Because of SSA, the redvar and target var of
+            # the current assignment would be different even
+            # though they refer to the same source-level var.
+            redvar_unver_name = reduction_var.unversioned_name
+            target_unver_name = inst.target.unversioned_name
+            is_same_source_var = redvar_unver_name == target_unver_name
+
+        if is_same_source_var:
+            # If redvar is different from target var, add an
+            # assignment to put target var into redvar.
+            if redvar_name != inst.target.name:
+                val = lowerer.loadvar(inst.target.name)
+                lowerer.storevar(val, name=redvar_name)
+                return True
+
+    return False
+
+def _create_shape_signature(
+        get_shape_classes,
+        num_inputs,
+        num_reductions,
+        args,
+        func_sig,
+        races,
+        typemap):
+    '''Create shape signature for GUFunc
+    '''
+    if config.DEBUG_ARRAY_OPT:
+        print("_create_shape_signature", num_inputs, num_reductions, args, races)
+        for i in args[1:]:
+            print("argument", i, type(i), get_shape_classes(i, typemap=typemap))
+
+    num_inouts = len(args) - num_reductions
+    # maximum class number for array shapes
+    classes = [get_shape_classes(var, typemap=typemap) if var not in races else (-1,) for var in args[1:]]
+    class_set = set()
+    for _class in classes:
+        if _class:
+            for i in _class:
+                class_set.add(i)
+    max_class = max(class_set) + 1 if class_set else 0
+    classes.insert(0, (max_class,)) # force set the class of 'sched' argument
+    class_set.add(max_class)
+    thread_num_class = max_class + 1
+    class_set.add(thread_num_class)
+    class_map = {}
+    # TODO: use prefix + class number instead of single char
+    alphabet = ord('a')
+    for n in class_set:
+       if n >= 0:
+           class_map[n] = chr(alphabet)
+           alphabet += 1
+    threadcount_ordinal = chr(alphabet)
+
+    alpha_dict = {'latest_alpha' : alphabet}
+
+    def bump_alpha(c, class_map):
+        if c >= 0:
+            return class_map[c]
+        else:
+            alpha_dict['latest_alpha'] += 1
+            return chr(alpha_dict['latest_alpha'])
+
+    gu_sin = []
+    gu_sout = []
+    count = 0
+    syms_sin = ()
+    if config.DEBUG_ARRAY_OPT:
+        print("args", args)
+        print("classes", classes)
+        print("threadcount_ordinal", threadcount_ordinal)
+    for cls, arg in zip(classes, args):
+        count = count + 1
+        if cls:
+            dim_syms = tuple(bump_alpha(c, class_map) for c in cls)
+        else:
+            dim_syms = ()
+        if (count > num_inouts):
+            # Add the threadcount_ordinal to represent the thread count
+            # to the start of the reduction array.
+            gu_sin.append(tuple([threadcount_ordinal] + list(dim_syms[1:])))
+        else:
+            gu_sin.append(dim_syms)
+            syms_sin += dim_syms
+    return (gu_sin, gu_sout)
+
+def _print_block(block):
+    for i, inst in enumerate(block.body):
+        print("    ", i, " ", inst)
+
+def _print_body(body_dict):
+    '''Pretty-print a set of IR blocks.
+    '''
+    topo_order = wrap_find_topo(body_dict)
+    for label in topo_order:
+        block = body_dict[label]
+        print("label: ", label)
+        _print_block(block)
+
+
+def wrap_loop_body(loop_body):
+    blocks = loop_body.copy()  # shallow copy is enough
+    first_label = min(blocks.keys())
+    last_label = max(blocks.keys())
+    loc = blocks[last_label].loc
+    blocks[last_label].body.append(ir.Jump(first_label, loc))
+    return blocks
+
+def unwrap_loop_body(loop_body):
+    last_label = max(loop_body.keys())
+    loop_body[last_label].body = loop_body[last_label].body[:-1]
+
+def add_to_def_once_sets(a_def, def_once, def_more):
+    '''If the variable is already defined more than once, do nothing.
+       Else if defined exactly once previously then transition this
+       variable to the defined more than once set (remove it from
+       def_once set and add to def_more set).
+       Else this must be the first time we've seen this variable defined
+       so add to def_once set.
+    '''
+    if a_def in def_more:
+        pass
+    elif a_def in def_once:
+        def_more.add(a_def)
+        def_once.remove(a_def)
+    else:
+        def_once.add(a_def)
+
+def compute_def_once_block(block, def_once, def_more, getattr_taken, typemap, module_assigns):
+    '''Effect changes to the set of variables defined once or more than once
+       for a single block.
+       block - the block to process
+       def_once - set of variable names known to be defined exactly once
+       def_more - set of variable names known to be defined more than once
+       getattr_taken - dict mapping variable name to tuple of object and attribute taken
+       module_assigns - dict mapping variable name to the Global that they came from
+    '''
+    # The only "defs" occur in assignments, so find such instructions.
+    assignments = block.find_insts(ir.Assign)
+    # For each assignment...
+    for one_assign in assignments:
+        # Get the LHS/target of the assignment.
+        a_def = one_assign.target.name
+        # Add variable to def sets.
+        add_to_def_once_sets(a_def, def_once, def_more)
+
+        rhs = one_assign.value
+        if isinstance(rhs, ir.Global):
+            # Remember assignments of the form "a = Global(...)"
+            # Is this a module?
+            if isinstance(rhs.value, pytypes.ModuleType):
+                module_assigns[a_def] = rhs.value.__name__
+        if isinstance(rhs, ir.Expr) and rhs.op == 'getattr' and rhs.value.name in def_once:
+            # Remember assignments of the form "a = b.c"
+            getattr_taken[a_def] = (rhs.value.name, rhs.attr)
+        if isinstance(rhs, ir.Expr) and rhs.op == 'call' and rhs.func.name in getattr_taken:
+            # If "a" is being called then lookup the getattr definition of "a"
+            # as above, getting the module variable "b" (base_obj)
+            # and the attribute "c" (base_attr).
+            base_obj, base_attr = getattr_taken[rhs.func.name]
+            if base_obj in module_assigns:
+                # If we know the definition of the module variable then get the module
+                # name from module_assigns.
+                base_mod_name = module_assigns[base_obj]
+                if not is_const_call(base_mod_name, base_attr):
+                    # Calling a method on an object could modify the object and is thus
+                    # like a def of that object.  We call is_const_call to see if this module/attribute
+                    # combination is known to not modify the module state.  If we don't know that
+                    # the combination is safe then we have to assume there could be a modification to
+                    # the module and thus add the module variable as defined more than once.
+                    add_to_def_once_sets(base_obj, def_once, def_more)
+            else:
+                # Assume the worst and say that base_obj could be modified by the call.
+                add_to_def_once_sets(base_obj, def_once, def_more)
+        if isinstance(rhs, ir.Expr) and rhs.op == 'call':
+            # If a mutable object is passed to a function, then it may be changed and
+            # therefore can't be hoisted.
+            # For each argument to the function...
+            for argvar in rhs.args:
+                # Get the argument's type.
+                if isinstance(argvar, ir.Var):
+                    argvar = argvar.name
+                avtype = typemap[argvar]
+                # If that type doesn't have a mutable attribute or it does and it's set to
+                # not mutable then this usage is safe for hoisting.
+                if getattr(avtype, 'mutable', False):
+                    # Here we have a mutable variable passed to a function so add this variable
+                    # to the def lists.
+                    add_to_def_once_sets(argvar, def_once, def_more)
+
+def wrap_find_topo(loop_body):
+    blocks = wrap_loop_body(loop_body)
+    topo_order = find_topo_order(blocks)
+    unwrap_loop_body(loop_body)
+    return topo_order
+
+def compute_def_once_internal(loop_body, def_once, def_more, getattr_taken, typemap, module_assigns):
+    '''Compute the set of variables defined exactly once in the given set of blocks
+       and use the given sets for storing which variables are defined once, more than
+       once and which have had a getattr call on them.
+    '''
+    # For each block in topological order...
+    topo_order = wrap_find_topo(loop_body)
+    for label in topo_order:
+        block = loop_body[label]
+        # Scan this block and effect changes to def_once, def_more, and getattr_taken
+        # based on the instructions in that block.
+        compute_def_once_block(block, def_once, def_more, getattr_taken, typemap, module_assigns)
+        # Have to recursively process parfors manually here.
+        for inst in block.body:
+            if isinstance(inst, parfor.Parfor):
+                # Recursively compute for the parfor's init block.
+                compute_def_once_block(inst.init_block, def_once, def_more, getattr_taken, typemap, module_assigns)
+                # Recursively compute for the parfor's loop body.
+                compute_def_once_internal(inst.loop_body, def_once, def_more, getattr_taken, typemap, module_assigns)
+
+def compute_def_once(loop_body, typemap):
+    '''Compute the set of variables defined exactly once in the given set of blocks.
+    '''
+    def_once = set()   # set to hold variables defined exactly once
+    def_more = set()   # set to hold variables defined more than once
+    getattr_taken = {}
+    module_assigns = {}
+    compute_def_once_internal(loop_body, def_once, def_more, getattr_taken, typemap, module_assigns)
+    return def_once, def_more
+
+def find_vars(var, varset):
+    assert isinstance(var, ir.Var)
+    varset.add(var.name)
+    return var
+
+def _hoist_internal(inst, dep_on_param, call_table, hoisted, not_hoisted,
+                    typemap, stored_arrays):
+    if inst.target.name in stored_arrays:
+        not_hoisted.append((inst, "stored array"))
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("Instruction", inst, "could not be hoisted because the created array is stored.")
+        return False
+
+    target_type = typemap[inst.target.name]
+
+    uses = set()
+    # Get vars used by this statement.
+    visit_vars_inner(inst.value, find_vars, uses)
+    # Filter out input parameters from the set of variable usages.
+    unhoistable = {assgn.target.name for assgn, _ in not_hoisted}
+    use_unhoist = uses & unhoistable
+    diff = uses.difference(dep_on_param)
+    diff |= use_unhoist
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("_hoist_internal:", inst, "uses:", uses, "diff:", diff)
+    if len(diff) == 0 and is_pure(inst.value, None, call_table):
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("Will hoist instruction", inst, target_type)
+        hoisted.append(inst)
+        if not isinstance(target_type, types.npytypes.Array):
+            dep_on_param += [inst.target.name]
+        return True
+    else:
+        if len(diff) > 0:
+            not_hoisted.append((inst, "dependency"))
+            if config.DEBUG_ARRAY_OPT >= 1:
+                print("Instruction", inst, "could not be hoisted because of a dependency.")
+        else:
+            not_hoisted.append((inst, "not pure"))
+            if config.DEBUG_ARRAY_OPT >= 1:
+                print("Instruction", inst, "could not be hoisted because it isn't pure.")
+    return False
+
+def find_setitems_block(setitems, itemsset, block, typemap):
+    for inst in block.body:
+        if isinstance(inst, (ir.StaticSetItem, ir.SetItem)):
+            setitems.add(inst.target.name)
+            # If we store a non-mutable object into an array then that is safe to hoist.
+            # If the stored object is mutable and you hoist then multiple entries in the
+            # outer array could reference the same object and changing one index would then
+            # change other indices.
+            if getattr(typemap[inst.value.name], "mutable", False):
+                itemsset.add(inst.value.name)
+        elif isinstance(inst, parfor.Parfor):
+            find_setitems_block(setitems, itemsset, inst.init_block, typemap)
+            find_setitems_body(setitems, itemsset, inst.loop_body, typemap)
+        elif isinstance(inst, ir.Assign):
+            # If something of mutable type is given to a build_tuple or
+            # used in a call then consider it unanalyzable and so
+            # unavailable for hoisting.
+            rhs = inst.value
+            def add_to_itemset(item):
+                assert isinstance(item, ir.Var), rhs
+                if getattr(typemap[item.name], "mutable", False):
+                    itemsset.add(item.name)
+
+            if isinstance(rhs, ir.Expr):
+                if rhs.op in ["build_tuple", "build_list", "build_set"]:
+                    for item in rhs.items:
+                        add_to_itemset(item)
+                elif rhs.op == "build_map":
+                    for pair in rhs.items:
+                        for item in pair:
+                            add_to_itemset(item)
+                elif rhs.op == "call":
+                    for item in list(rhs.args) + [x[1] for x in rhs.kws]:
+                        add_to_itemset(item)
+
+def find_setitems_body(setitems, itemsset, loop_body, typemap):
+    """
+      Find the arrays that are written into (goes into setitems) and the
+      mutable objects (mostly arrays) that are written into other arrays
+      (goes into itemsset).
+    """
+    for label, block in loop_body.items():
+        find_setitems_block(setitems, itemsset, block, typemap)
+
+def empty_container_allocator_hoist(inst, dep_on_param, call_table, hoisted,
+                                    not_hoisted, typemap, stored_arrays):
+    if (isinstance(inst, ir.Assign) and
+        isinstance(inst.value, ir.Expr) and
+        inst.value.op == 'call' and
+        inst.value.func.name in call_table):
+        call_list = call_table[inst.value.func.name]
+        if call_list == ['empty', np]:
+            return _hoist_internal(inst, dep_on_param, call_table, hoisted,
+                                   not_hoisted, typemap, stored_arrays)
+    return False
+
+def hoist(parfor_params, loop_body, typemap, wrapped_blocks):
+    dep_on_param = copy.copy(parfor_params)
+    hoisted = []
+    not_hoisted = []
+
+    # Compute the set of variable defined exactly once in the loop body.
+    def_once, def_more = compute_def_once(loop_body, typemap)
+    (call_table, reverse_call_table) = get_call_table(wrapped_blocks)
+
+    setitems = set()
+    itemsset = set()
+    find_setitems_body(setitems, itemsset, loop_body, typemap)
+    dep_on_param = list(set(dep_on_param).difference(setitems))
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("hoist - def_once:", def_once, "setitems:", setitems, "itemsset:", itemsset, "dep_on_param:", dep_on_param, "parfor_params:", parfor_params)
+    for si in setitems:
+        add_to_def_once_sets(si, def_once, def_more)
+
+    for label, block in loop_body.items():
+        new_block = []
+        for inst in block.body:
+            if empty_container_allocator_hoist(inst, dep_on_param, call_table,
+                                   hoisted, not_hoisted, typemap, itemsset):
+                continue
+            elif isinstance(inst, ir.Assign) and inst.target.name in def_once:
+                if _hoist_internal(inst, dep_on_param, call_table,
+                                   hoisted, not_hoisted, typemap, itemsset):
+                    # don't add this instruction to the block since it is
+                    # hoisted
+                    continue
+            elif isinstance(inst, parfor.Parfor):
+                new_init_block = []
+                if config.DEBUG_ARRAY_OPT >= 1:
+                    print("parfor")
+                    inst.dump()
+                for ib_inst in inst.init_block.body:
+                    if empty_container_allocator_hoist(ib_inst, dep_on_param,
+                        call_table, hoisted, not_hoisted, typemap, itemsset):
+                        continue
+                    elif (isinstance(ib_inst, ir.Assign) and
+                        ib_inst.target.name in def_once):
+                        if _hoist_internal(ib_inst, dep_on_param, call_table,
+                                           hoisted, not_hoisted, typemap,
+                                           itemsset):
+                            # don't add this instruction to the block since it is hoisted
+                            continue
+                    new_init_block.append(ib_inst)
+                inst.init_block.body = new_init_block
+
+            new_block.append(inst)
+        block.body = new_block
+    return hoisted, not_hoisted
+
+def redtyp_is_scalar(redtype):
+    return not isinstance(redtype, types.npytypes.Array)
+
+def redtyp_to_redarraytype(redtyp):
+    """Go from a reducation variable type to a reduction array type used to hold
+       per-worker results.
+    """
+    redarrdim = 1
+    # If the reduction type is an array then allocate reduction array with ndim+1 dimensions.
+    if isinstance(redtyp, types.npytypes.Array):
+        redarrdim += redtyp.ndim
+        # We don't create array of array but multi-dimensional reduction array with same dtype.
+        redtyp = redtyp.dtype
+    return types.npytypes.Array(redtyp, redarrdim, "C")
+
+def redarraytype_to_sig(redarraytyp):
+    """Given a reduction array type, find the type of the reduction argument to the gufunc.
+    """
+    assert isinstance(redarraytyp, types.npytypes.Array)
+    return types.npytypes.Array(redarraytyp.dtype, redarraytyp.ndim, redarraytyp.layout)
+
+def legalize_names_with_typemap(names, typemap):
+    """ We use ir_utils.legalize_names to replace internal IR variable names
+        containing illegal characters (e.g. period) with a legal character
+        (underscore) so as to create legal variable names.
+        The original variable names are in the typemap so we also
+        need to add the legalized name to the typemap as well.
+    """
+    outdict = legalize_names(names)
+    # For each pair in the dict of legalized names...
+    for x, y in outdict.items():
+        # If the name had some legalization change to it...
+        if x != y:
+            # Set the type of the new name the same as the type of the old name.
+            typemap[y] = typemap[x]
+    return outdict
+
+def to_scalar_from_0d(x):
+    if isinstance(x, types.ArrayCompatible):
+        if x.ndim == 0:
+            return x.dtype
+    return x
+
+def _create_gufunc_for_parfor_body(
+        lowerer,
+        parfor,
+        typemap,
+        typingctx,
+        targetctx,
+        flags,
+        locals,
+        has_aliases,
+        index_var_typ,
+        races):
+    '''
+    Takes a parfor and creates a gufunc function for its body.
+    There are two parts to this function.
+    1) Code to iterate across the iteration space as defined by the schedule.
+    2) The parfor body that does the work for a single point in the iteration space.
+    Part 1 is created as Python text for simplicity with a sentinel assignment to mark the point
+    in the IR where the parfor body should be added.
+    This Python text is 'exec'ed into existence and its IR retrieved with run_frontend.
+    The IR is scanned for the sentinel assignment where that basic block is split and the IR
+    for the parfor body inserted.
+    '''
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("starting _create_gufunc_for_parfor_body")
+
+    loc = parfor.init_block.loc
+
+    # The parfor body and the main function body share ir.Var nodes.
+    # We have to do some replacements of Var names in the parfor body to make them
+    # legal parameter names.  If we don't copy then the Vars in the main function also
+    # would incorrectly change their name.
+    loop_body = copy.copy(parfor.loop_body)
+    remove_dels(loop_body)
+
+    parfor_dim = len(parfor.loop_nests)
+    loop_indices = [l.index_variable.name for l in parfor.loop_nests]
+
+    # Get all the parfor params.
+    parfor_params = parfor.params
+    # Get just the outputs of the parfor.
+    parfor_outputs = numba.parfors.parfor.get_parfor_outputs(parfor, parfor_params)
+    # Get all parfor reduction vars, and operators.
+    typemap = lowerer.fndesc.typemap
+    parfor_redvars, parfor_reddict = numba.parfors.parfor.get_parfor_reductions(
+        lowerer.func_ir, parfor, parfor_params, lowerer.fndesc.calltypes)
+    # Compute just the parfor inputs as a set difference.
+    parfor_inputs = sorted(
+        list(
+            set(parfor_params) -
+            set(parfor_outputs) -
+            set(parfor_redvars)))
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("parfor_params = ", parfor_params, " ", type(parfor_params))
+        print("parfor_outputs = ", parfor_outputs, " ", type(parfor_outputs))
+        print("parfor_inputs = ", parfor_inputs, " ", type(parfor_inputs))
+        print("parfor_redvars = ", parfor_redvars, " ", type(parfor_redvars))
+
+    # -------------------------------------------------------------------------
+    # Convert tuples to individual parameters.
+    tuple_expanded_parfor_inputs = []
+    tuple_var_to_expanded_names = {}
+    expanded_name_to_tuple_var = {}
+    next_expanded_tuple_var = 0
+    parfor_tuple_params = []
+    # For each input to the parfor.
+    for pi in parfor_inputs:
+        # Get the type of the input.
+        pi_type = typemap[pi]
+        # If it is a UniTuple or Tuple we will do the conversion.
+        if isinstance(pi_type, types.UniTuple) or isinstance(pi_type, types.NamedUniTuple):
+            # Get the size and dtype of the tuple.
+            tuple_count = pi_type.count
+            tuple_dtype = pi_type.dtype
+            # Only do tuples up to config.PARFOR_MAX_TUPLE_SIZE length.
+            assert(tuple_count <= config.PARFOR_MAX_TUPLE_SIZE)
+            this_var_expansion = []
+            for i in range(tuple_count):
+                # Generate a new name for the individual part of the tuple var.
+                expanded_name = "expanded_tuple_var_" + str(next_expanded_tuple_var)
+                # Add that name to the new list of inputs to the gufunc.
+                tuple_expanded_parfor_inputs.append(expanded_name)
+                this_var_expansion.append(expanded_name)
+                # Remember a mapping from new param name to original tuple
+                # var and the index within the tuple.
+                expanded_name_to_tuple_var[expanded_name] = (pi, i)
+                next_expanded_tuple_var += 1
+                # Set the type of the new parameter.
+                typemap[expanded_name] = tuple_dtype
+            # Remember a mapping from the original tuple var to the
+            # individual parts.
+            tuple_var_to_expanded_names[pi] = this_var_expansion
+            parfor_tuple_params.append(pi)
+        elif isinstance(pi_type, types.Tuple) or isinstance(pi_type, types.NamedTuple):
+            # This is the same as above for UniTuple except that each part of
+            # the tuple can have a different type and we fetch that type with
+            # pi_type.types[offset].
+            tuple_count = pi_type.count
+            tuple_types = pi_type.types
+            # Only do tuples up to config.PARFOR_MAX_TUPLE_SIZE length.
+            assert(tuple_count <= config.PARFOR_MAX_TUPLE_SIZE)
+            this_var_expansion = []
+            for i in range(tuple_count):
+                expanded_name = "expanded_tuple_var_" + str(next_expanded_tuple_var)
+                tuple_expanded_parfor_inputs.append(expanded_name)
+                this_var_expansion.append(expanded_name)
+                expanded_name_to_tuple_var[expanded_name] = (pi, i)
+                next_expanded_tuple_var += 1
+                typemap[expanded_name] = tuple_types[i]
+            tuple_var_to_expanded_names[pi] = this_var_expansion
+            parfor_tuple_params.append(pi)
+        else:
+            tuple_expanded_parfor_inputs.append(pi)
+    parfor_inputs = tuple_expanded_parfor_inputs
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("parfor_inputs post tuple handling = ", parfor_inputs, " ", type(parfor_inputs))
+    # -------------------------------------------------------------------------
+
+    races = races.difference(set(parfor_redvars))
+    for race in races:
+        msg = ("Variable %s used in parallel loop may be written "
+               "to simultaneously by multiple workers and may result "
+               "in non-deterministic or unintended results." % race)
+        warnings.warn(NumbaParallelSafetyWarning(msg, loc))
+    replace_var_with_array(races, loop_body, typemap, lowerer.fndesc.calltypes)
+
+    # Reduction variables are represented as arrays, so they go under
+    # different names.
+    parfor_redarrs = []
+    parfor_red_arg_types = []
+    for var in parfor_redvars:
+        arr = var + "_arr"
+        parfor_redarrs.append(arr)
+        redarraytype = redtyp_to_redarraytype(typemap[var])
+        parfor_red_arg_types.append(redarraytype)
+        redarrsig = redarraytype_to_sig(redarraytype)
+        if arr in typemap:
+            assert(typemap[arr] == redarrsig)
+        else:
+            typemap[arr] = redarrsig
+
+    # Reorder all the params so that inputs go first then outputs.
+    parfor_params = parfor_inputs + parfor_outputs + parfor_redarrs
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("parfor_params = ", parfor_params, " ", type(parfor_params))
+        print("loop_indices = ", loop_indices, " ", type(loop_indices))
+        print("loop_body = ", loop_body, " ", type(loop_body))
+        _print_body(loop_body)
+
+    # Some Var are not legal parameter names so create a dict of potentially illegal
+    # param name to guaranteed legal name.
+    param_dict = legalize_names_with_typemap(parfor_params + parfor_redvars + parfor_tuple_params, typemap)
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print(
+            "param_dict = ",
+            sorted(
+                param_dict.items()),
+            " ",
+            type(param_dict))
+
+    # Some loop_indices are not legal parameter names so create a dict of potentially illegal
+    # loop index to guaranteed legal name.
+    ind_dict = legalize_names_with_typemap(loop_indices, typemap)
+    # Compute a new list of legal loop index names.
+    legal_loop_indices = [ind_dict[v] for v in loop_indices]
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("ind_dict = ", sorted(ind_dict.items()), " ", type(ind_dict))
+        print(
+            "legal_loop_indices = ",
+            legal_loop_indices,
+            " ",
+            type(legal_loop_indices))
+        for pd in parfor_params:
+            print("pd = ", pd)
+            print("pd type = ", typemap[pd], " ", type(typemap[pd]))
+
+    # Get the types of each parameter.
+    param_types = [to_scalar_from_0d(typemap[v]) for v in parfor_params]
+    # Calculate types of args passed to gufunc.
+    func_arg_types = [typemap[v] for v in (parfor_inputs + parfor_outputs)] + parfor_red_arg_types
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("new param_types:", param_types)
+        print("new func_arg_types:", func_arg_types)
+
+    # Replace illegal parameter names in the loop body with legal ones.
+    replace_var_names(loop_body, param_dict)
+    # remember the name before legalizing as the actual arguments
+    parfor_args = parfor_params
+    # Change parfor_params to be legal names.
+    parfor_params = [param_dict[v] for v in parfor_params]
+    parfor_params_orig = parfor_params
+
+    parfor_params = []
+    ascontig = False
+    for pindex in range(len(parfor_params_orig)):
+        if (ascontig and
+            pindex < len(parfor_inputs) and
+            isinstance(param_types[pindex], types.npytypes.Array)):
+            parfor_params.append(parfor_params_orig[pindex]+"param")
+        else:
+            parfor_params.append(parfor_params_orig[pindex])
+
+    # Change parfor body to replace illegal loop index vars with legal ones.
+    replace_var_names(loop_body, ind_dict)
+    loop_body_var_table = get_name_var_table(loop_body)
+    sentinel_name = get_unused_var_name("__sentinel__", loop_body_var_table)
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print(
+            "legal parfor_params = ",
+            parfor_params,
+            " ",
+            type(parfor_params))
+
+    # Determine the unique names of the scheduling and gufunc functions.
+    # sched_func_name = "__numba_parfor_sched_%s" % (hex(hash(parfor)).replace("-", "_"))
+    gufunc_name = "__numba_parfor_gufunc_%s" % (
+        hex(hash(parfor)).replace("-", "_"))
+    if config.DEBUG_ARRAY_OPT:
+        # print("sched_func_name ", type(sched_func_name), " ", sched_func_name)
+        print("gufunc_name ", type(gufunc_name), " ", gufunc_name)
+
+    gufunc_txt = ""
+
+    # Create the gufunc function.
+    gufunc_txt += "def " + gufunc_name + \
+        "(sched, " + (", ".join(parfor_params)) + "):\n"
+
+    globls = {"np": np, "numba": numba}
+
+    # First thing in the gufunc, we reconstruct tuples from their
+    # individual parts, e.g., orig_tup_name = (part1, part2,).
+    # The rest of the code of the function will use the original tuple name.
+    for tup_var, exp_names in tuple_var_to_expanded_names.items():
+        tup_type = typemap[tup_var]
+        gufunc_txt += "    " + param_dict[tup_var]
+        # Determine if the tuple is a named tuple.
+        if (isinstance(tup_type, types.NamedTuple) or
+            isinstance(tup_type, types.NamedUniTuple)):
+            named_tup = True
+        else:
+            named_tup = False
+
+        if named_tup:
+            # It is a named tuple so try to find the global that defines the
+            # named tuple.
+            func_def = guard(get_definition, lowerer.func_ir, tup_var)
+            named_tuple_def = None
+            if config.DEBUG_ARRAY_OPT:
+                print("func_def:", func_def, type(func_def))
+            if func_def is not None:
+                if (isinstance(func_def, ir.Expr) and
+                    func_def.op == 'call'):
+                    named_tuple_def = guard(get_definition, lowerer.func_ir, func_def.func)
+                    if config.DEBUG_ARRAY_OPT:
+                        print("named_tuple_def:", named_tuple_def, type(named_tuple_def))
+                elif isinstance(func_def, ir.Arg):
+                    named_tuple_def = typemap[func_def.name]
+                    if config.DEBUG_ARRAY_OPT:
+                        print("named_tuple_def:", named_tuple_def,
+                              type(named_tuple_def), named_tuple_def.name)
+            if named_tuple_def is not None:
+                if (isinstance(named_tuple_def, ir.Global) or
+                    isinstance(named_tuple_def, ir.FreeVar)):
+                    gval = named_tuple_def.value
+                    if config.DEBUG_ARRAY_OPT:
+                        print("gval:", gval, type(gval))
+                    globls[named_tuple_def.name] = gval
+                elif isinstance(named_tuple_def, types.containers.BaseNamedTuple):
+                    named_tuple_name = named_tuple_def.name.split('(')[0]
+                    if config.DEBUG_ARRAY_OPT:
+                        print("name:", named_tuple_name,
+                              named_tuple_def.instance_class,
+                              type(named_tuple_def.instance_class))
+                    globls[named_tuple_name] = named_tuple_def.instance_class
+            else:
+                if config.DEBUG_ARRAY_OPT:
+                    print("Didn't find definition of namedtuple for globls.")
+                raise CompilerError("Could not find definition of " + str(tup_var),
+                                     tup_var.loc)
+            gufunc_txt += " = " + tup_type.instance_class.__name__ + "("
+            for name, field_name in zip(exp_names, tup_type.fields):
+                gufunc_txt += field_name + "=" + param_dict[name] + ","
+        else:
+            # Just a regular tuple so use (part0, part1, ...)
+            gufunc_txt += " = (" + ", ".join([param_dict[x] for x in exp_names])
+            if len(exp_names) == 1:
+                # Add comma for tuples with singular values.  We can't unilaterally
+                # add a comma always because (,) isn't valid.
+                gufunc_txt += ","
+
+        gufunc_txt += ")\n"
+
+    for pindex in range(len(parfor_inputs)):
+        if ascontig and isinstance(param_types[pindex], types.npytypes.Array):
+            gufunc_txt += ("    " + parfor_params_orig[pindex]
+                + " = np.ascontiguousarray(" + parfor_params[pindex] + ")\n")
+
+    gufunc_thread_id_var = "ParallelAcceleratorGufuncThreadId"
+
+    if len(parfor_redarrs) > 0:
+        gufunc_txt += "    " + gufunc_thread_id_var + " = "
+        gufunc_txt += "numba.np.ufunc.parallel._iget_thread_id()\n"
+
+    # Add initialization of reduction variables
+    for arr, var in zip(parfor_redarrs, parfor_redvars):
+        gufunc_txt += "    " + param_dict[var] + \
+             "=" + param_dict[arr] + "[" + gufunc_thread_id_var + "]\n"
+        if config.DEBUG_ARRAY_OPT_RUNTIME:
+            gufunc_txt += "    print(\"thread id =\", ParallelAcceleratorGufuncThreadId)\n"
+            gufunc_txt += "    print(\"initial reduction value\",ParallelAcceleratorGufuncThreadId," + param_dict[var] + "," + param_dict[var] + ".shape)\n"
+            gufunc_txt += "    print(\"reduction array\",ParallelAcceleratorGufuncThreadId," + param_dict[arr] + "," + param_dict[arr] + ".shape)\n"
+
+    # For each dimension of the parfor, create a for loop in the generated gufunc function.
+    # Iterate across the proper values extracted from the schedule.
+    # The form of the schedule is start_dim0, start_dim1, ..., start_dimN, end_dim0,
+    # end_dim1, ..., end_dimN
+    for eachdim in range(parfor_dim):
+        for indent in range(eachdim + 1):
+            gufunc_txt += "    "
+        sched_dim = eachdim
+        gufunc_txt += ("for " +
+                       legal_loop_indices[eachdim] +
+                       " in range(sched[" +
+                       str(sched_dim) +
+                       "], sched[" +
+                       str(sched_dim +
+                           parfor_dim) +
+                       "] + np.uint8(1)):\n")
+
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        for indent in range(parfor_dim + 1):
+            gufunc_txt += "    "
+        gufunc_txt += "print("
+        for eachdim in range(parfor_dim):
+            gufunc_txt += "\"" + legal_loop_indices[eachdim] + "\"," + legal_loop_indices[eachdim] + ","
+        gufunc_txt += ")\n"
+
+    # Add the sentinel assignment so that we can find the loop body position
+    # in the IR.
+    for indent in range(parfor_dim + 1):
+        gufunc_txt += "    "
+    gufunc_txt += sentinel_name + " = 0\n"
+    # Add assignments of reduction variables (for returning the value)
+    for arr, var in zip(parfor_redarrs, parfor_redvars):
+        if config.DEBUG_ARRAY_OPT_RUNTIME:
+            gufunc_txt += "    print(\"final reduction value\",ParallelAcceleratorGufuncThreadId," + param_dict[var] + ")\n"
+            gufunc_txt += "    print(\"final reduction array\",ParallelAcceleratorGufuncThreadId," + param_dict[arr] + ")\n"
+        # After the gufunc loops, copy the accumulated temp value back to reduction array.
+        gufunc_txt += "    " + param_dict[arr] + \
+            "[" + gufunc_thread_id_var + "] = " + param_dict[var] + "\n"
+    gufunc_txt += "    return None\n"
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_txt = ", type(gufunc_txt), "\n", gufunc_txt)
+        print("globls:", globls, type(globls))
+    # Force gufunc outline into existence.
+    locls = {}
+    exec(gufunc_txt, globls, locls)
+    gufunc_func = locls[gufunc_name]
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_func = ", type(gufunc_func), "\n", gufunc_func)
+    # Get the IR for the gufunc outline.
+    gufunc_ir = compiler.run_frontend(gufunc_func)
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir dump ", type(gufunc_ir))
+        gufunc_ir.dump()
+        print("loop_body dump ", type(loop_body))
+        _print_body(loop_body)
+
+    # rename all variables in gufunc_ir afresh
+    var_table = get_name_var_table(gufunc_ir.blocks)
+    new_var_dict = {}
+    reserved_names = [sentinel_name] + \
+        list(param_dict.values()) + legal_loop_indices
+    for name, var in var_table.items():
+        if not (name in reserved_names):
+            new_var_dict[name] = parfor.init_block.scope.redefine(name, loc).name
+    replace_var_names(gufunc_ir.blocks, new_var_dict)
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir dump after renaming ")
+        gufunc_ir.dump()
+    gufunc_param_types = [types.npytypes.Array(
+            index_var_typ, 1, "C")] + param_types
+    if config.DEBUG_ARRAY_OPT:
+        print(
+            "gufunc_param_types = ",
+            type(gufunc_param_types),
+            "\n",
+            gufunc_param_types)
+
+    gufunc_stub_last_label = find_max_label(gufunc_ir.blocks) + 1
+
+    # Add gufunc stub last label to each parfor.loop_body label to prevent
+    # label conflicts.
+    loop_body = add_offset_to_labels(loop_body, gufunc_stub_last_label)
+    # new label for splitting sentinel block
+    new_label = find_max_label(loop_body) + 1
+
+    # If enabled, add a print statement after every assignment.
+    if config.DEBUG_ARRAY_OPT_RUNTIME:
+        for label, block in loop_body.items():
+            new_block = block.copy()
+            new_block.clear()
+            loc = block.loc
+            scope = block.scope
+            for inst in block.body:
+                new_block.append(inst)
+                # Append print after assignment
+                if isinstance(inst, ir.Assign):
+                    # Only apply to numbers
+                    if typemap[inst.target.name] not in types.number_domain:
+                        continue
+
+                    # Make constant string
+                    strval = "{} =".format(inst.target.name)
+                    strconsttyp = types.StringLiteral(strval)
+
+                    lhs = scope.redefine("str_const", loc)
+                    # lhs = ir.Var(scope, mk_unique_var("str_const"), loc)
+                    assign_lhs = ir.Assign(value=ir.Const(value=strval, loc=loc),
+                                           target=lhs, loc=loc)
+                    typemap[lhs.name] = strconsttyp
+                    new_block.append(assign_lhs)
+
+                    # Make print node
+                    print_node = ir.Print(args=[lhs, inst.target], vararg=None, loc=loc)
+                    new_block.append(print_node)
+                    sig = numba.core.typing.signature(types.none,
+                                           typemap[lhs.name],
+                                           typemap[inst.target.name])
+                    lowerer.fndesc.calltypes[print_node] = sig
+            loop_body[label] = new_block
+
+    if config.DEBUG_ARRAY_OPT:
+        print("parfor loop body")
+        _print_body(loop_body)
+
+    wrapped_blocks = wrap_loop_body(loop_body)
+    hoisted, not_hoisted = hoist(parfor_params, loop_body, typemap, wrapped_blocks)
+    start_block = gufunc_ir.blocks[min(gufunc_ir.blocks.keys())]
+    start_block.body = start_block.body[:-1] + hoisted + [start_block.body[-1]]
+    unwrap_loop_body(loop_body)
+
+    # store hoisted into diagnostics
+    diagnostics = lowerer.metadata['parfor_diagnostics']
+    diagnostics.hoist_info[parfor.id] = {'hoisted': hoisted,
+                                         'not_hoisted': not_hoisted}
+
+    if config.DEBUG_ARRAY_OPT:
+        print("After hoisting")
+        _print_body(loop_body)
+
+    # Search all the block in the gufunc outline for the sentinel assignment.
+    for label, block in gufunc_ir.blocks.items():
+        for i, inst in enumerate(block.body):
+            if isinstance(
+                    inst,
+                    ir.Assign) and inst.target.name == sentinel_name:
+                # We found the sentinel assignment.
+                loc = inst.loc
+                scope = block.scope
+                # split block across __sentinel__
+                # A new block is allocated for the statements prior to the sentinel
+                # but the new block maintains the current block label.
+                prev_block = ir.Block(scope, loc)
+                prev_block.body = block.body[:i]
+                # The current block is used for statements after the sentinel.
+                block.body = block.body[i + 1:]
+                # But the current block gets a new label.
+                body_first_label = min(loop_body.keys())
+
+                # The previous block jumps to the minimum labelled block of the
+                # parfor body.
+                prev_block.append(ir.Jump(body_first_label, loc))
+                # Add all the parfor loop body blocks to the gufunc function's
+                # IR.
+                for (l, b) in loop_body.items():
+                    gufunc_ir.blocks[l] = transfer_scope(b, scope)
+                body_last_label = max(loop_body.keys())
+                gufunc_ir.blocks[new_label] = block
+                gufunc_ir.blocks[label] = prev_block
+                # Add a jump from the last parfor body block to the block containing
+                # statements after the sentinel.
+                gufunc_ir.blocks[body_last_label].append(
+                    ir.Jump(new_label, loc))
+                break
+        else:
+            continue
+        break
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir last dump before renaming")
+        gufunc_ir.dump()
+
+    gufunc_ir.blocks = rename_labels(gufunc_ir.blocks)
+    remove_dels(gufunc_ir.blocks)
+
+    if config.DEBUG_ARRAY_OPT:
+        print("gufunc_ir last dump")
+        gufunc_ir.dump()
+        print("flags", flags)
+        print("typemap", typemap)
+
+    old_alias = flags.noalias
+    if not has_aliases:
+        if config.DEBUG_ARRAY_OPT:
+            print("No aliases found so adding noalias flag.")
+        flags.noalias = True
+
+    fixup_var_define_in_scope(gufunc_ir.blocks)
+
+    class ParforGufuncCompiler(compiler.CompilerBase):
+        def define_pipelines(self):
+            from numba.core.compiler_machinery import PassManager
+            dpb = compiler.DefaultPassBuilder
+            pm = PassManager("full_parfor_gufunc")
+            parfor_gufunc_passes = dpb.define_parfor_gufunc_pipeline(self.state)
+            pm.passes.extend(parfor_gufunc_passes.passes)
+            lowering_passes = dpb.define_parfor_gufunc_nopython_lowering_pipeline(self.state)
+            pm.passes.extend(lowering_passes.passes)
+
+            pm.finalize()
+            return [pm]
+
+    kernel_func = compiler.compile_ir(
+        typingctx,
+        targetctx,
+        gufunc_ir,
+        gufunc_param_types,
+        types.none,
+        flags,
+        locals,
+        pipeline_class=ParforGufuncCompiler)
+
+    flags.noalias = old_alias
+
+    kernel_sig = signature(types.none, *gufunc_param_types)
+    if config.DEBUG_ARRAY_OPT:
+        print("finished create_gufunc_for_parfor_body. kernel_sig = ", kernel_sig)
+
+    return kernel_func, parfor_args, kernel_sig, func_arg_types, expanded_name_to_tuple_var
+
+def replace_var_with_array_in_block(vars, block, typemap, calltypes):
+    new_block = []
+    for inst in block.body:
+        if isinstance(inst, ir.Assign) and inst.target.name in vars:
+            loc = inst.loc
+            scope = inst.target.scope
+
+            const_node = ir.Const(0, loc)
+            const_var = scope.redefine("$const_ind_0", loc)
+            typemap[const_var.name] = types.uintp
+            const_assign = ir.Assign(const_node, const_var, loc)
+            new_block.append(const_assign)
+
+            val_var = scope.redefine("$val", loc)
+            typemap[val_var.name] = typemap[inst.target.name]
+            new_block.append(ir.Assign(inst.value, val_var, loc))
+            setitem_node = ir.SetItem(inst.target, const_var, val_var, loc)
+            calltypes[setitem_node] = signature(
+                types.none, types.npytypes.Array(typemap[inst.target.name], 1, "C"), types.intp, typemap[inst.target.name])
+            new_block.append(setitem_node)
+            continue
+        elif isinstance(inst, parfor.Parfor):
+            replace_var_with_array_internal(vars, {0: inst.init_block}, typemap, calltypes)
+            replace_var_with_array_internal(vars, inst.loop_body, typemap, calltypes)
+
+        new_block.append(inst)
+    return new_block
+
+def replace_var_with_array_internal(vars, loop_body, typemap, calltypes):
+    for label, block in loop_body.items():
+        block.body = replace_var_with_array_in_block(vars, block, typemap, calltypes)
+
+def replace_var_with_array(vars, loop_body, typemap, calltypes):
+    replace_var_with_array_internal(vars, loop_body, typemap, calltypes)
+    for v in vars:
+        el_typ = typemap[v]
+        typemap.pop(v, None)
+        typemap[v] = types.npytypes.Array(el_typ, 1, "C")
+
+def call_parallel_gufunc(lowerer, cres, gu_signature, outer_sig, expr_args, expr_arg_types,
+                         loop_ranges, redvars, reddict, redarrdict, init_block, index_var_typ, races,
+                         exp_name_to_tuple_var):
+    '''
+    Adds the call to the gufunc function from the main function.
+    '''
+    context = lowerer.context
+    builder = lowerer.builder
+
+    from numba.np.ufunc.parallel import (build_gufunc_wrapper,
+                           _launch_threads)
+
+    if config.DEBUG_ARRAY_OPT:
+        print("make_parallel_loop")
+        print("outer_sig = ", outer_sig.args, outer_sig.return_type,
+              outer_sig.recvr, outer_sig.pysig)
+        print("loop_ranges = ", loop_ranges)
+        print("expr_args", expr_args)
+        print("expr_arg_types", expr_arg_types)
+        print("gu_signature", gu_signature)
+
+    # Build the wrapper for GUFunc
+    args, return_type = sigutils.normalize_signature(outer_sig)
+    llvm_func = cres.library.get_function(cres.fndesc.llvm_func_name)
+    sin, sout = gu_signature
+
+    # These are necessary for build_gufunc_wrapper to find external symbols
+    _launch_threads()
+
+    info = build_gufunc_wrapper(llvm_func, cres, sin, sout,
+                                cache=False, is_parfors=True)
+    wrapper_name = info.name
+    cres.library._ensure_finalized()
+
+    if config.DEBUG_ARRAY_OPT:
+        print("parallel function = ", wrapper_name, cres)
+
+    # loadvars for loop_ranges
+    def load_range(v):
+        if isinstance(v, ir.Var):
+            return lowerer.loadvar(v.name)
+        else:
+            return context.get_constant(types.uintp, v)
+
+    num_dim = len(loop_ranges)
+    for i in range(num_dim):
+        start, stop, step = loop_ranges[i]
+        start = load_range(start)
+        stop = load_range(stop)
+        assert(step == 1)  # We do not support loop steps other than 1
+        step = load_range(step)
+        loop_ranges[i] = (start, stop, step)
+
+        if config.DEBUG_ARRAY_OPT:
+            print("call_parallel_gufunc loop_ranges[{}] = ".format(i), start,
+                  stop, step)
+            cgutils.printf(builder, "loop range[{}]: %d %d (%d)\n".format(i),
+                           start, stop, step)
+
+    # Commonly used LLVM types and constants
+    byte_t = llvmlite.ir.IntType(8)
+    byte_ptr_t = llvmlite.ir.PointerType(byte_t)
+    byte_ptr_ptr_t = llvmlite.ir.PointerType(byte_ptr_t)
+    intp_t = context.get_value_type(types.intp)
+    uintp_t = context.get_value_type(types.uintp)
+    intp_ptr_t = llvmlite.ir.PointerType(intp_t)
+    intp_ptr_ptr_t = llvmlite.ir.PointerType(intp_ptr_t)
+    uintp_ptr_t = llvmlite.ir.PointerType(uintp_t)
+    uintp_ptr_ptr_t = llvmlite.ir.PointerType(uintp_ptr_t)
+    zero = context.get_constant(types.uintp, 0)
+    one = context.get_constant(types.uintp, 1)
+    one_type = one.type
+    sizeof_intp = context.get_abi_sizeof(intp_t)
+
+    # Prepare sched, first pop it out of expr_args, outer_sig, and gu_signature
+    expr_args.pop(0)
+    sched_sig = sin.pop(0)
+
+    if config.DEBUG_ARRAY_OPT:
+        print("Parfor has potentially negative start", index_var_typ.signed)
+
+    if index_var_typ.signed:
+        sched_type = intp_t
+        sched_ptr_type = intp_ptr_t
+        sched_ptr_ptr_type = intp_ptr_ptr_t
+    else:
+        sched_type = uintp_t
+        sched_ptr_type = uintp_ptr_t
+        sched_ptr_ptr_type = uintp_ptr_ptr_t
+
+    # Call do_scheduling with appropriate arguments
+    dim_starts = cgutils.alloca_once(
+        builder, sched_type, size=context.get_constant(
+            types.uintp, num_dim), name="dim_starts")
+    dim_stops = cgutils.alloca_once(
+        builder, sched_type, size=context.get_constant(
+            types.uintp, num_dim), name="dim_stops")
+    for i in range(num_dim):
+        start, stop, step = loop_ranges[i]
+        if start.type != one_type:
+            start = builder.sext(start, one_type)
+        if stop.type != one_type:
+            stop = builder.sext(stop, one_type)
+        if step.type != one_type:
+            step = builder.sext(step, one_type)
+        # substract 1 because do-scheduling takes inclusive ranges
+        stop = builder.sub(stop, one)
+        builder.store(
+            start, builder.gep(
+                dim_starts, [
+                    context.get_constant(
+                        types.uintp, i)]))
+        builder.store(stop, builder.gep(dim_stops,
+                                        [context.get_constant(types.uintp, i)]))
+
+    # Prepare to call get/set parallel_chunksize and get the number of threads.
+    get_chunksize = cgutils.get_or_insert_function(
+        builder.module,
+        llvmlite.ir.FunctionType(uintp_t, []),
+        name="get_parallel_chunksize")
+
+    set_chunksize = cgutils.get_or_insert_function(
+        builder.module,
+        llvmlite.ir.FunctionType(llvmlite.ir.VoidType(), [uintp_t]),
+        name="set_parallel_chunksize")
+
+    get_num_threads = cgutils.get_or_insert_function(
+        builder.module,
+        llvmlite.ir.FunctionType(llvmlite.ir.IntType(types.intp.bitwidth), []),
+        "get_num_threads")
+
+    # Get the current number of threads.
+    num_threads = builder.call(get_num_threads, [])
+    # Get the current chunksize so we can use it and restore the value later.
+    current_chunksize = builder.call(get_chunksize, [])
+
+    with cgutils.if_unlikely(builder, builder.icmp_signed('<=', num_threads,
+                                                  num_threads.type(0))):
+        cgutils.printf(builder, "num_threads: %d\n", num_threads)
+        context.call_conv.return_user_exc(builder, RuntimeError,
+                                                  ("Invalid number of threads. "
+                                                   "This likely indicates a bug in Numba.",))
+
+    # Call get_sched_size from gufunc_scheduler.cpp that incorporates the size of the work,
+    # the number of threads and the selected chunk size.  This will tell us how many entries
+    # in the schedule we will need.
+    get_sched_size_fnty = llvmlite.ir.FunctionType(uintp_t, [uintp_t, uintp_t, intp_ptr_t, intp_ptr_t])
+    get_sched_size = cgutils.get_or_insert_function(
+        builder.module,
+        get_sched_size_fnty,
+        name="get_sched_size")
+    num_divisions = builder.call(get_sched_size, [num_threads,
+                                                  context.get_constant(types.uintp, num_dim),
+                                                  dim_starts,
+                                                  dim_stops])
+    # Set the chunksize to zero so that any nested calls get the default chunk size behavior.
+    builder.call(set_chunksize, [zero])
+
+    # Each entry in the schedule is 2 times the number of dimensions long.
+    multiplier = context.get_constant(types.uintp, num_dim * 2)
+    # Compute the total number of entries in the schedule.
+    sched_size = builder.mul(num_divisions, multiplier)
+
+    # Prepare to dynamically allocate memory to hold the schedule.
+    alloc_sched_fnty = llvmlite.ir.FunctionType(sched_ptr_type, [uintp_t])
+    alloc_sched_func = cgutils.get_or_insert_function(
+        builder.module,
+        alloc_sched_fnty,
+        name="allocate_sched")
+    # Call gufunc_scheduler.cpp to allocate the schedule.
+    # This may or may not do pooling.
+    alloc_space = builder.call(alloc_sched_func, [sched_size])
+    # Allocate a slot in the entry block to store the schedule pointer.
+    sched = cgutils.alloca_once(builder, sched_ptr_type)
+    # Store the schedule pointer into that slot.
+    builder.store(alloc_space, sched)
+
+    debug_flag = 1 if config.DEBUG_ARRAY_OPT else 0
+    scheduling_fnty = llvmlite.ir.FunctionType(
+        intp_ptr_t, [uintp_t, intp_ptr_t, intp_ptr_t, uintp_t, sched_ptr_type, intp_t])
+    if index_var_typ.signed:
+        do_scheduling = cgutils.get_or_insert_function(builder.module,
+                                                       scheduling_fnty,
+                                                       name="do_scheduling_signed")
+    else:
+        do_scheduling = cgutils.get_or_insert_function(builder.module,
+                                                       scheduling_fnty,
+                                                       name="do_scheduling_unsigned")
+
+    # Call the scheduling routine that decides how to break up the work.
+    builder.call(
+        do_scheduling, [
+            context.get_constant(
+                types.uintp, num_dim), dim_starts, dim_stops, num_divisions,
+            builder.load(sched), context.get_constant(
+                    types.intp, debug_flag)])
+
+    # Get the LLVM vars for the Numba IR reduction array vars.
+    redarrs = [lowerer.loadvar(redarrdict[x].name) for x in redvars]
+
+    nredvars = len(redvars)
+    ninouts = len(expr_args) - nredvars
+
+    def load_potential_tuple_var(x):
+        """Given a variable name, if that variable is not a new name
+           introduced as the extracted part of a tuple then just return
+           the variable loaded from its name.  However, if the variable
+           does represent part of a tuple, as recognized by the name of
+           the variable being present in the exp_name_to_tuple_var dict,
+           then we load the original tuple var instead that we get from
+           the dict and then extract the corresponding element of the
+           tuple, also stored and returned to use in the dict (i.e., offset).
+        """
+        if x in exp_name_to_tuple_var:
+            orig_tup, offset = exp_name_to_tuple_var[x]
+            tup_var = lowerer.loadvar(orig_tup)
+            res = builder.extract_value(tup_var, offset)
+            return res
+        else:
+            return lowerer.loadvar(x)
+
+    # ----------------------------------------------------------------------------
+    # Prepare arguments: args, shapes, steps, data
+    all_args = [load_potential_tuple_var(x) for x in expr_args[:ninouts]] + redarrs
+    num_args = len(all_args)
+    num_inps = len(sin) + 1
+    args = cgutils.alloca_once(
+        builder,
+        byte_ptr_t,
+        size=context.get_constant(
+            types.intp,
+            1 + num_args),
+        name="pargs")
+    array_strides = []
+    # sched goes first
+    builder.store(builder.bitcast(builder.load(sched), byte_ptr_t), args)
+    array_strides.append(context.get_constant(types.intp, sizeof_intp))
+    rv_to_arg_dict = {}
+    # followed by other arguments
+    for i in range(num_args):
+        arg = all_args[i]
+        var = expr_args[i]
+        aty = expr_arg_types[i]
+        dst = builder.gep(args, [context.get_constant(types.intp, i + 1)])
+        if i >= ninouts:  # reduction variables
+            ary = context.make_array(aty)(context, builder, arg)
+            strides = cgutils.unpack_tuple(builder, ary.strides, aty.ndim)
+            # Start from 1 because we skip the first dimension of length num_threads just like sched.
+            for j in range(len(strides)):
+                array_strides.append(strides[j])
+            builder.store(builder.bitcast(ary.data, byte_ptr_t), dst)
+        elif isinstance(aty, types.ArrayCompatible):
+            if var in races:
+                typ = (context.get_data_type(aty.dtype)
+                       if aty.dtype != types.boolean
+                       else llvmlite.ir.IntType(1))
+
+                rv_arg = cgutils.alloca_once(builder, typ)
+                builder.store(arg, rv_arg)
+                builder.store(builder.bitcast(rv_arg, byte_ptr_t), dst)
+                rv_to_arg_dict[var] = (arg, rv_arg)
+
+                array_strides.append(context.get_constant(types.intp, context.get_abi_sizeof(typ)))
+            else:
+                ary = context.make_array(aty)(context, builder, arg)
+                strides = cgutils.unpack_tuple(builder, ary.strides, aty.ndim)
+                for j in range(len(strides)):
+                    array_strides.append(strides[j])
+                builder.store(builder.bitcast(ary.data, byte_ptr_t), dst)
+        else:
+            if i < num_inps:
+                # Scalar input, need to store the value in an array of size 1
+                if isinstance(aty, types.Optional):
+                    # Unpack optional type
+                    unpacked_aty = aty.type
+                    arg = context.cast(builder, arg, aty, unpacked_aty)
+                else:
+                    unpacked_aty = aty
+                typ = (context.get_data_type(unpacked_aty)
+                       if not isinstance(unpacked_aty, types.Boolean)
+                       else llvmlite.ir.IntType(1))
+                ptr = cgutils.alloca_once(builder, typ)
+                builder.store(arg, ptr)
+            else:
+                # Scalar output, must allocate
+                typ = (context.get_data_type(aty)
+                       if not isinstance(aty, types.Boolean)
+                       else llvmlite.ir.IntType(1))
+                ptr = cgutils.alloca_once(builder, typ)
+            builder.store(builder.bitcast(ptr, byte_ptr_t), dst)
+
+    # ----------------------------------------------------------------------------
+    # Next, we prepare the individual dimension info recorded in gu_signature
+    sig_dim_dict = {}
+    occurrences = []
+    occurrences = [sched_sig[0]]
+    sig_dim_dict[sched_sig[0]] = context.get_constant(types.intp, 2 * num_dim)
+    assert len(expr_args) == len(all_args)
+    assert len(expr_args) == len(expr_arg_types)
+    assert len(expr_args) == len(sin + sout)
+    assert len(expr_args) == len(outer_sig.args[1:])
+    for var, arg, aty, gu_sig in zip(expr_args, all_args,
+                                     expr_arg_types, sin + sout):
+        if isinstance(aty, types.npytypes.Array):
+            i = aty.ndim - len(gu_sig)
+        else:
+            i = 0
+        if config.DEBUG_ARRAY_OPT:
+            print("var =", var, "gu_sig =", gu_sig, "type =", aty, "i =", i)
+
+        for dim_sym in gu_sig:
+            if config.DEBUG_ARRAY_OPT:
+                print("var = ", var, " type = ", aty)
+            if var in races:
+                sig_dim_dict[dim_sym] = context.get_constant(types.intp, 1)
+            else:
+                ary = context.make_array(aty)(context, builder, arg)
+                shapes = cgutils.unpack_tuple(builder, ary.shape, aty.ndim)
+                sig_dim_dict[dim_sym] = shapes[i]
+
+            if not (dim_sym in occurrences):
+                if config.DEBUG_ARRAY_OPT:
+                    print("dim_sym = ", dim_sym, ", i = ", i)
+                    cgutils.printf(builder, dim_sym + " = %d\n", sig_dim_dict[dim_sym])
+                occurrences.append(dim_sym)
+            i = i + 1
+
+    # ----------------------------------------------------------------------------
+    # Prepare shapes, which is a single number (outer loop size), followed by
+    # the size of individual shape variables.
+    nshapes = len(sig_dim_dict) + 1
+    shapes = cgutils.alloca_once(builder, intp_t, size=nshapes, name="pshape")
+    # For now, outer loop size is the same as number of threads
+    builder.store(num_divisions, shapes)
+    # Individual shape variables go next
+    i = 1
+    for dim_sym in occurrences:
+        if config.DEBUG_ARRAY_OPT:
+            cgutils.printf(builder, dim_sym + " = %d\n", sig_dim_dict[dim_sym])
+        builder.store(
+            sig_dim_dict[dim_sym], builder.gep(
+                shapes, [
+                    context.get_constant(
+                        types.intp, i)]))
+        i = i + 1
+
+    # ----------------------------------------------------------------------------
+    # Prepare steps for each argument. Note that all steps are counted in
+    # bytes.
+    num_steps = num_args + 1 + len(array_strides)
+    steps = cgutils.alloca_once(
+        builder, intp_t, size=context.get_constant(
+            types.intp, num_steps), name="psteps")
+    # First goes the step size for sched, which is 2 * num_dim
+    builder.store(context.get_constant(types.intp, 2 * num_dim * sizeof_intp),
+                  steps)
+    # The steps for all others are 0, except for reduction results.
+    for i in range(num_args):
+        # steps are strides from one thread to the next
+        stepsize = zero
+
+        dst = builder.gep(steps, [context.get_constant(types.intp, 1 + i)])
+        builder.store(stepsize, dst)
+    for j in range(len(array_strides)):
+        dst = builder.gep(
+            steps, [
+                context.get_constant(
+                    types.intp, 1 + num_args + j)])
+        builder.store(array_strides[j], dst)
+
+    # ----------------------------------------------------------------------------
+    # prepare data
+    data = cgutils.get_null_value(byte_ptr_t)
+
+    fnty = llvmlite.ir.FunctionType(llvmlite.ir.VoidType(),
+                                    [byte_ptr_ptr_t, intp_ptr_t,
+                                     intp_ptr_t, byte_ptr_t])
+
+    fn = cgutils.get_or_insert_function(builder.module, fnty, wrapper_name)
+    context.active_code_library.add_linking_library(info.library)
+
+    if config.DEBUG_ARRAY_OPT:
+        cgutils.printf(builder, "before calling kernel %p\n", fn)
+    builder.call(fn, [args, shapes, steps, data])
+    if config.DEBUG_ARRAY_OPT:
+        cgutils.printf(builder, "after calling kernel %p\n", fn)
+
+    builder.call(set_chunksize, [current_chunksize])
+
+    # Deallocate the schedule's memory.
+    dealloc_sched_fnty = llvmlite.ir.FunctionType(llvmlite.ir.VoidType(), [sched_ptr_type])
+    dealloc_sched_func = cgutils.get_or_insert_function(
+        builder.module,
+        dealloc_sched_fnty,
+        name="deallocate_sched")
+    builder.call(dealloc_sched_func, [builder.load(sched)])
+
+    for k, v in rv_to_arg_dict.items():
+        arg, rv_arg = v
+        only_elem_ptr = builder.gep(rv_arg, [context.get_constant(types.intp, 0)])
+        builder.store(builder.load(only_elem_ptr), lowerer.getvar(k))
+
+    context.active_code_library.add_linking_library(cres.library)

shared/package-files/d1/d121f02fccfb396a6b51507770b045025bf49b4fef45febd8a287ed64461618d/blob

@@ -0,0 +1,410 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Generic, Literal, Protocol
+
+from narwhals._compliant.any_namespace import (
+    CatNamespace,
+    DateTimeNamespace,
+    ListNamespace,
+    StringNamespace,
+    StructNamespace,
+)
+from narwhals._compliant.column import CompliantColumn
+from narwhals._compliant.typing import (
+    CompliantSeriesT_co,
+    EagerDataFrameAny,
+    EagerSeriesT,
+    EagerSeriesT_co,
+    NativeSeriesT,
+    NativeSeriesT_co,
+)
+from narwhals._translate import FromIterable, FromNative, NumpyConvertible, ToNarwhals
+from narwhals._typing_compat import TypeVar, assert_never
+from narwhals._utils import (
+    _StoresCompliant,
+    _StoresNative,
+    is_compliant_series,
+    is_sized_multi_index_selector,
+    unstable,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Sequence
+    from types import ModuleType
+
+    import pandas as pd
+    import polars as pl
+    import pyarrow as pa
+    from typing_extensions import NotRequired, Self, TypedDict
+
+    from narwhals._compliant.dataframe import CompliantDataFrame
+    from narwhals._compliant.namespace import EagerNamespace
+    from narwhals._utils import Implementation, Version, _LimitedContext
+    from narwhals.dtypes import DType
+    from narwhals.series import Series
+    from narwhals.typing import (
+        Into1DArray,
+        IntoDType,
+        MultiIndexSelector,
+        PythonLiteral,
+        RollingInterpolationMethod,
+        SizedMultiIndexSelector,
+        _1DArray,
+        _SliceIndex,
+    )
+
+    class HistData(TypedDict, Generic[NativeSeriesT, "_CountsT_co"]):
+        breakpoint: NotRequired[list[float] | _1DArray | list[Any]]
+        count: NativeSeriesT | _1DArray | _CountsT_co | list[Any]
+
+
+_CountsT_co = TypeVar("_CountsT_co", bound="Iterable[Any]", covariant=True)
+
+__all__ = [
+    "CompliantSeries",
+    "EagerSeries",
+    "EagerSeriesCatNamespace",
+    "EagerSeriesDateTimeNamespace",
+    "EagerSeriesHist",
+    "EagerSeriesListNamespace",
+    "EagerSeriesNamespace",
+    "EagerSeriesStringNamespace",
+    "EagerSeriesStructNamespace",
+]
+
+
+class CompliantSeries(
+    NumpyConvertible["_1DArray", "Into1DArray"],
+    FromIterable,
+    FromNative[NativeSeriesT],
+    ToNarwhals["Series[NativeSeriesT]"],
+    CompliantColumn,
+    Protocol[NativeSeriesT],
+):
+    # NOTE: `narwhals`
+    _implementation: Implementation
+
+    @property
+    def native(self) -> NativeSeriesT: ...
+    def __narwhals_series__(self) -> Self:
+        return self
+
+    def __native_namespace__(self) -> ModuleType: ...
+    @classmethod
+    def from_native(cls, data: NativeSeriesT, /, *, context: _LimitedContext) -> Self: ...
+    def to_narwhals(self) -> Series[NativeSeriesT]:
+        return self._version.series(self, level="full")
+
+    def _with_native(self, series: Any) -> Self: ...
+    def _with_version(self, version: Version) -> Self: ...
+
+    # NOTE: `polars`
+    @property
+    def dtype(self) -> DType: ...
+    @property
+    def name(self) -> str: ...
+    def __array__(self, dtype: Any, *, copy: bool | None) -> _1DArray: ...
+    def __contains__(self, other: Any) -> bool: ...
+    def __getitem__(self, item: MultiIndexSelector[Self]) -> Any: ...
+    def __iter__(self) -> Iterator[Any]: ...
+    def __len__(self) -> int:
+        return len(self.native)
+
+    @classmethod
+    def from_numpy(cls, data: Into1DArray, /, *, context: _LimitedContext) -> Self: ...
+    @classmethod
+    def from_iterable(
+        cls,
+        data: Iterable[Any],
+        /,
+        *,
+        context: _LimitedContext,
+        name: str = "",
+        dtype: IntoDType | None = None,
+    ) -> Self: ...
+    def __radd__(self, other: Any) -> Self: ...
+    def __rand__(self, other: Any) -> Self: ...
+    def __rmul__(self, other: Any) -> Self: ...
+    def __ror__(self, other: Any) -> Self: ...
+    def all(self) -> bool: ...
+    def any(self) -> bool: ...
+    def any_value(self, *, ignore_nulls: bool) -> PythonLiteral: ...
+    def arg_max(self) -> int: ...
+    def arg_min(self) -> int: ...
+    def arg_true(self) -> Self: ...
+    def count(self) -> int: ...
+    def filter(self, predicate: Any) -> Self: ...
+    def first(self) -> PythonLiteral: ...
+    def last(self) -> PythonLiteral: ...
+    def gather_every(self, n: int, offset: int) -> Self: ...
+    def head(self, n: int) -> Self: ...
+    def is_empty(self) -> bool:
+        return self.len() == 0
+
+    def is_sorted(self, *, descending: bool) -> bool: ...
+    def item(self, index: int | None) -> Any: ...
+    def kurtosis(self) -> float | None: ...
+    def len(self) -> int: ...
+    def max(self) -> Any: ...
+    def mean(self) -> float: ...
+    def median(self) -> float: ...
+    def min(self) -> Any: ...
+    def n_unique(self) -> int: ...
+    def null_count(self) -> int: ...
+    def quantile(
+        self, quantile: float, interpolation: RollingInterpolationMethod
+    ) -> float: ...
+    def sample(self, n: int, *, with_replacement: bool, seed: int | None) -> Self: ...
+    def scatter(self, indices: Self, values: Self) -> Self: ...
+    def shift(self, n: int) -> Self: ...
+    def skew(self) -> float | None: ...
+    def sort(self, *, descending: bool, nulls_last: bool) -> Self: ...
+    def std(self, *, ddof: int) -> float: ...
+    def sum(self) -> float: ...
+    def tail(self, n: int) -> Self: ...
+    def to_arrow(self) -> pa.Array[Any]: ...
+    def to_dummies(
+        self, *, separator: str, drop_first: bool
+    ) -> CompliantDataFrame[Self, Any, Any, Any]: ...
+    def to_frame(self) -> CompliantDataFrame[Self, Any, Any, Any]: ...
+    def to_list(self) -> list[Any]: ...
+    def to_pandas(self) -> pd.Series[Any]: ...
+    def to_polars(self) -> pl.Series: ...
+    def unique(self, *, maintain_order: bool = False) -> Self: ...
+    def value_counts(
+        self, *, sort: bool, parallel: bool, name: str | None, normalize: bool
+    ) -> CompliantDataFrame[Self, Any, Any, Any]: ...
+    def var(self, *, ddof: int) -> float: ...
+    def zip_with(self, mask: Any, other: Any) -> Self: ...
+
+    # NOTE: *Technically* `polars`
+    @unstable
+    def hist_from_bins(
+        self, bins: list[float], *, include_breakpoint: bool
+    ) -> CompliantDataFrame[Self, Any, Any, Any]:
+        """`Series.hist(bins=..., bin_count=None)`."""
+        ...
+
+    @unstable
+    def hist_from_bin_count(
+        self, bin_count: int, *, include_breakpoint: bool
+    ) -> CompliantDataFrame[Self, Any, Any, Any]:
+        """`Series.hist(bins=None, bin_count=...)`."""
+        ...
+
+
+class EagerSeries(CompliantSeries[NativeSeriesT], Protocol[NativeSeriesT]):
+    _native_series: Any
+    _implementation: Implementation
+    _version: Version
+    _broadcast: bool
+
+    @property
+    def _backend_version(self) -> tuple[int, ...]:
+        return self._implementation._backend_version()
+
+    @classmethod
+    def _align_full_broadcast(cls, *series: Self) -> Sequence[Self]:
+        """Ensure all of `series` have the same length (and index if `pandas`).
+
+        Scalars get broadcasted to the full length of the longest Series.
+
+        This is useful when you need to construct a full Series anyway, such as:
+
+            DataFrame.select(...)
+
+        It should not be used in binary operations, such as:
+
+            nw.col("a") - nw.col("a").mean()
+
+        because then it's more efficient to extract the right-hand-side's single element as a scalar.
+        """
+        ...
+
+    def _from_scalar(self, value: Any) -> Self:
+        return self.from_iterable([value], name=self.name, context=self)
+
+    def _with_native(
+        self, series: NativeSeriesT, *, preserve_broadcast: bool = False
+    ) -> Self:
+        """Return a new `CompliantSeries`, wrapping the native `series`.
+
+        In cases when operations are known to not affect whether a result should
+        be broadcast, we can pass `preserve_broadcast=True`.
+        Set this with care - it should only be set for unary expressions which don't
+        change length or order, such as `.alias` or `.fill_null`. If in doubt, don't
+        set it, you probably don't need it.
+        """
+        ...
+
+    def __narwhals_namespace__(
+        self,
+    ) -> EagerNamespace[Any, Self, Any, Any, NativeSeriesT]: ...
+
+    def _gather(self, rows: SizedMultiIndexSelector[NativeSeriesT]) -> Self: ...
+    def _gather_slice(self, rows: _SliceIndex | range) -> Self: ...
+    def __getitem__(self, item: MultiIndexSelector[Self]) -> Self:
+        if isinstance(item, (slice, range)):
+            return self._gather_slice(item)
+        if is_compliant_series(item):
+            return self._gather(item.native)
+        elif is_sized_multi_index_selector(item):  # noqa: RET505
+            return self._gather(item)
+        assert_never(item)
+
+    @property
+    def str(self) -> EagerSeriesStringNamespace[Self, NativeSeriesT]: ...
+    @property
+    def dt(self) -> EagerSeriesDateTimeNamespace[Self, NativeSeriesT]: ...
+    @property
+    def cat(self) -> EagerSeriesCatNamespace[Self, NativeSeriesT]: ...
+    @property
+    def list(self) -> EagerSeriesListNamespace[Self, NativeSeriesT]: ...
+    @property
+    def struct(self) -> EagerSeriesStructNamespace[Self, NativeSeriesT]: ...
+
+
+class _SeriesNamespace(  # type: ignore[misc]
+    _StoresCompliant[CompliantSeriesT_co],
+    _StoresNative[NativeSeriesT_co],
+    Protocol[CompliantSeriesT_co, NativeSeriesT_co],
+):
+    _compliant_series: CompliantSeriesT_co
+
+    @property
+    def compliant(self) -> CompliantSeriesT_co:
+        return self._compliant_series
+
+    @property
+    def implementation(self) -> Implementation:
+        return self.compliant._implementation
+
+    @property
+    def backend_version(self) -> tuple[int, ...]:
+        return self.implementation._backend_version()
+
+    @property
+    def version(self) -> Version:
+        return self.compliant._version
+
+    @property
+    def native(self) -> NativeSeriesT_co:
+        return self._compliant_series.native  # type: ignore[no-any-return]
+
+    def with_native(self, series: Any, /) -> CompliantSeriesT_co:
+        return self.compliant._with_native(series)
+
+
+class EagerSeriesNamespace(
+    _SeriesNamespace[EagerSeriesT_co, NativeSeriesT_co],
+    Generic[EagerSeriesT_co, NativeSeriesT_co],
+):
+    _compliant_series: EagerSeriesT_co
+
+    def __init__(self, series: EagerSeriesT_co, /) -> None:
+        self._compliant_series = series
+
+
+class EagerSeriesCatNamespace(  # type: ignore[misc]
+    _SeriesNamespace[EagerSeriesT_co, NativeSeriesT_co],
+    CatNamespace[EagerSeriesT_co],
+    Protocol[EagerSeriesT_co, NativeSeriesT_co],
+): ...
+
+
+class EagerSeriesDateTimeNamespace(  # type: ignore[misc]
+    _SeriesNamespace[EagerSeriesT_co, NativeSeriesT_co],
+    DateTimeNamespace[EagerSeriesT_co],
+    Protocol[EagerSeriesT_co, NativeSeriesT_co],
+): ...
+
+
+class EagerSeriesListNamespace(  # pyright: ignore[reportInvalidTypeVarUse]
+    _SeriesNamespace[EagerSeriesT, NativeSeriesT_co],
+    ListNamespace[EagerSeriesT],
+    Protocol[EagerSeriesT, NativeSeriesT_co],
+): ...
+
+
+class EagerSeriesStringNamespace(
+    _SeriesNamespace[EagerSeriesT, NativeSeriesT_co],
+    StringNamespace[EagerSeriesT],
+    Protocol[EagerSeriesT, NativeSeriesT_co],
+): ...
+
+
+class EagerSeriesStructNamespace(  # type: ignore[misc]
+    _SeriesNamespace[EagerSeriesT_co, NativeSeriesT_co],
+    StructNamespace[EagerSeriesT_co],
+    Protocol[EagerSeriesT_co, NativeSeriesT_co],
+): ...
+
+
+# mypy says: `Covariant type variable "_CountsT_co" used in protocol where invariant one is expected`
+class EagerSeriesHist(Protocol[NativeSeriesT, _CountsT_co]):  # type: ignore[misc]
+    _series: EagerSeries[NativeSeriesT]
+    _breakpoint: bool
+    _data: HistData[NativeSeriesT, _CountsT_co]
+
+    @property
+    def native(self) -> NativeSeriesT:
+        return self._series.native
+
+    @classmethod
+    def from_series(
+        cls, series: EagerSeries[NativeSeriesT], *, include_breakpoint: bool
+    ) -> Self:
+        obj = cls.__new__(cls)
+        obj._series = series
+        obj._breakpoint = include_breakpoint
+        return obj
+
+    def to_frame(self) -> EagerDataFrameAny: ...
+    def _linear_space(  # NOTE: Roughly `pl.linear_space`
+        self,
+        start: float,
+        end: float,
+        num_samples: int,
+        *,
+        closed: Literal["both", "none"] = "both",
+    ) -> _1DArray: ...
+
+    # NOTE: *Could* be handled at narwhals-level
+    def is_empty_series(self) -> bool: ...
+
+    # NOTE: **Should** be handled at narwhals-level
+    def data_empty(self) -> HistData[NativeSeriesT, _CountsT_co]:
+        return {"breakpoint": [], "count": []} if self._breakpoint else {"count": []}
+
+    # NOTE: *Could* be handled at narwhals-level, **iff** we add `nw.repeat`, `nw.linear_space`
+    # See https://github.com/narwhals-dev/narwhals/pull/2839#discussion_r2215630696
+    def series_empty(
+        self, arg: int | list[float], /
+    ) -> HistData[NativeSeriesT, _CountsT_co]: ...
+
+    def with_bins(self, bins: list[float], /) -> Self:
+        if len(bins) <= 1:
+            self._data = self.data_empty()
+        elif self.is_empty_series():
+            self._data = self.series_empty(bins)
+        else:
+            self._data = self._calculate_hist(bins)
+        return self
+
+    def with_bin_count(self, bin_count: int, /) -> Self:
+        if bin_count == 0:
+            self._data = self.data_empty()
+        elif self.is_empty_series():
+            self._data = self.series_empty(bin_count)
+        else:
+            self._data = self._calculate_hist(self._calculate_bins(bin_count))
+        return self
+
+    def _calculate_breakpoint(self, arg: int | list[float], /) -> list[float] | _1DArray:
+        bins = self._linear_space(0, 1, arg + 1) if isinstance(arg, int) else arg
+        return bins[1:]
+
+    def _calculate_bins(self, bin_count: int) -> _1DArray: ...
+    def _calculate_hist(
+        self, bins: list[float] | _1DArray
+    ) -> HistData[NativeSeriesT, _CountsT_co]: ...

shared/package-files/d1/d123e0b4c2614f680808b58cca0c140ba187494b2c8bcf8c604c7eb739c70882/blob

@@ -0,0 +1,28 @@
+# created by tools/loadICU.tcl -- do not edit
+namespace eval ::tcl::clock {
+    ::msgcat::mcset zh_HK DAYS_OF_WEEK_ABBREV [list \
+        "\u65e5"\
+        "\u4e00"\
+        "\u4e8c"\
+        "\u4e09"\
+        "\u56db"\
+        "\u4e94"\
+        "\u516d"]
+    ::msgcat::mcset zh_HK MONTHS_ABBREV [list \
+        "1\u6708"\
+        "2\u6708"\
+        "3\u6708"\
+        "4\u6708"\
+        "5\u6708"\
+        "6\u6708"\
+        "7\u6708"\
+        "8\u6708"\
+        "9\u6708"\
+        "10\u6708"\
+        "11\u6708"\
+        "12\u6708"\
+        ""]
+    ::msgcat::mcset zh_HK DATE_FORMAT "%Y\u5e74%m\u6708%e\u65e5"
+    ::msgcat::mcset zh_HK TIME_FORMAT_12 "%P%I:%M:%S"
+    ::msgcat::mcset zh_HK DATE_TIME_FORMAT "%Y\u5e74%m\u6708%e\u65e5 %P%I:%M:%S %z"
+}

shared/package-files/d1/d12457044da126028937f45fe199f4d282970bf4e46b779f3d6338ef383a0686/blob

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+import os
+import sys
+import tempfile
+
+
+def run_command(cmd):
+    print('Running %r:' % (cmd))
+    os.system(cmd)
+    print('------')
+
+
+def run():
+    _path = os.getcwd()
+    os.chdir(tempfile.gettempdir())
+    print('------')
+    print('os.name=%r' % (os.name))
+    print('------')
+    print('sys.platform=%r' % (sys.platform))
+    print('------')
+    print('sys.version:')
+    print(sys.version)
+    print('------')
+    print('sys.prefix:')
+    print(sys.prefix)
+    print('------')
+    print('sys.path=%r' % (':'.join(sys.path)))
+    print('------')
+
+    try:
+        import numpy
+        has_newnumpy = 1
+    except ImportError as e:
+        print('Failed to import new numpy:', e)
+        has_newnumpy = 0
+
+    try:
+        from numpy.f2py import f2py2e
+        has_f2py2e = 1
+    except ImportError as e:
+        print('Failed to import f2py2e:', e)
+        has_f2py2e = 0
+
+    try:
+        import numpy.distutils
+        has_numpy_distutils = 2
+    except ImportError:
+        try:
+            import numpy_distutils
+            has_numpy_distutils = 1
+        except ImportError as e:
+            print('Failed to import numpy_distutils:', e)
+            has_numpy_distutils = 0
+
+    if has_newnumpy:
+        try:
+            print('Found new numpy version %r in %s' %
+                  (numpy.__version__, numpy.__file__))
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+
+    if has_f2py2e:
+        try:
+            print('Found f2py2e version %r in %s' %
+                  (f2py2e.__version__.version, f2py2e.__file__))
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+
+    if has_numpy_distutils:
+        try:
+            if has_numpy_distutils == 2:
+                print('Found numpy.distutils version %r in %r' % (
+                    numpy.distutils.__version__,
+                    numpy.distutils.__file__))
+            else:
+                print('Found numpy_distutils version %r in %r' % (
+                    numpy_distutils.numpy_distutils_version.numpy_distutils_version,
+                    numpy_distutils.__file__))
+            print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+        try:
+            if has_numpy_distutils == 1:
+                print(
+                    'Importing numpy_distutils.command.build_flib ...', end=' ')
+                import numpy_distutils.command.build_flib as build_flib
+                print('ok')
+                print('------')
+                try:
+                    print(
+                        'Checking availability of supported Fortran compilers:')
+                    for compiler_class in build_flib.all_compilers:
+                        compiler_class(verbose=1).is_available()
+                        print('------')
+                except Exception as msg:
+                    print('error:', msg)
+                    print('------')
+        except Exception as msg:
+            print(
+                'error:', msg, '(ignore it, build_flib is obsolute for numpy.distutils 0.2.2 and up)')
+            print('------')
+        try:
+            if has_numpy_distutils == 2:
+                print('Importing numpy.distutils.fcompiler ...', end=' ')
+                import numpy.distutils.fcompiler as fcompiler
+            else:
+                print('Importing numpy_distutils.fcompiler ...', end=' ')
+                import numpy_distutils.fcompiler as fcompiler
+            print('ok')
+            print('------')
+            try:
+                print('Checking availability of supported Fortran compilers:')
+                fcompiler.show_fcompilers()
+                print('------')
+            except Exception as msg:
+                print('error:', msg)
+                print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+        try:
+            if has_numpy_distutils == 2:
+                print('Importing numpy.distutils.cpuinfo ...', end=' ')
+                from numpy.distutils.cpuinfo import cpuinfo
+                print('ok')
+                print('------')
+            else:
+                try:
+                    print(
+                        'Importing numpy_distutils.command.cpuinfo ...', end=' ')
+                    from numpy_distutils.command.cpuinfo import cpuinfo
+                    print('ok')
+                    print('------')
+                except Exception as msg:
+                    print('error:', msg, '(ignore it)')
+                    print('Importing numpy_distutils.cpuinfo ...', end=' ')
+                    from numpy_distutils.cpuinfo import cpuinfo
+                    print('ok')
+                    print('------')
+            cpu = cpuinfo()
+            print('CPU information:', end=' ')
+            for name in dir(cpuinfo):
+                if name[0] == '_' and name[1] != '_' and getattr(cpu, name[1:])():
+                    print(name[1:], end=' ')
+            print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+    os.chdir(_path)
+if __name__ == "__main__":
+    run()

shared/package-files/d1/d12495f2a5e115f03cf93f73bee59ab084fc6cd6cf5cb517e19419a740a80f39/blob

@@ -0,0 +1,10 @@
+"""Importable modules that enable the use of experimental features or estimators.
+
+.. warning::
+
+    The features and estimators that are experimental aren't subject to
+    deprecation cycles. Use them at your own risks!
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause

shared/package-files/d1/d1284cb753ddb8fdcafa7db41e3c6159140c39128ffeae2bb08458796ce80d1d/blob

@@ -0,0 +1,226 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "arrow/csv/invalid_row.h"
+#include "arrow/csv/type_fwd.h"
+#include "arrow/io/interfaces.h"
+#include "arrow/status.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow {
+
+class DataType;
+class TimestampParser;
+
+namespace csv {
+
+// Silly workaround for https://github.com/michaeljones/breathe/issues/453
+constexpr char kDefaultEscapeChar = '\\';
+
+struct ARROW_EXPORT ParseOptions {
+  // Parsing options
+
+  /// Field delimiter
+  char delimiter = ',';
+  /// Whether quoting is used
+  bool quoting = true;
+  /// Quoting character (if `quoting` is true)
+  char quote_char = '"';
+  /// Whether a quote inside a value is double-quoted
+  bool double_quote = true;
+  /// Whether escaping is used
+  bool escaping = false;
+  /// Escaping character (if `escaping` is true)
+  char escape_char = kDefaultEscapeChar;
+  /// Whether values are allowed to contain CR (0x0d) and LF (0x0a) characters
+  bool newlines_in_values = false;
+  /// Whether empty lines are ignored.  If false, an empty line represents
+  /// a single empty value (assuming a one-column CSV file).
+  bool ignore_empty_lines = true;
+  /// A handler function for rows which do not have the correct number of columns
+  InvalidRowHandler invalid_row_handler;
+
+  /// Create parsing options with default values
+  static ParseOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+struct ARROW_EXPORT ConvertOptions {
+  // Conversion options
+
+  /// Whether to check UTF8 validity of string columns
+  bool check_utf8 = true;
+  /// Optional per-column types (disabling type inference on those columns)
+  std::unordered_map<std::string, std::shared_ptr<DataType>> column_types;
+  /// Recognized spellings for null values
+  std::vector<std::string> null_values;
+  /// Recognized spellings for boolean true values
+  std::vector<std::string> true_values;
+  /// Recognized spellings for boolean false values
+  std::vector<std::string> false_values;
+
+  /// Whether string / binary columns can have null values.
+  ///
+  /// If true, then strings in "null_values" are considered null for string columns.
+  /// If false, then all strings are valid string values.
+  bool strings_can_be_null = false;
+
+  /// Whether quoted values can be null.
+  ///
+  /// If true, then strings in "null_values" are also considered null when they
+  /// appear quoted in the CSV file. Otherwise, quoted values are never considered null.
+  bool quoted_strings_can_be_null = true;
+
+  /// Whether to try to automatically dict-encode string / binary data.
+  /// If true, then when type inference detects a string or binary column,
+  /// it is dict-encoded up to `auto_dict_max_cardinality` distinct values
+  /// (per chunk), after which it switches to regular encoding.
+  ///
+  /// This setting is ignored for non-inferred columns (those in `column_types`).
+  bool auto_dict_encode = false;
+  int32_t auto_dict_max_cardinality = 50;
+
+  /// Decimal point character for floating-point and decimal data
+  char decimal_point = '.';
+
+  // XXX Should we have a separate FilterOptions?
+
+  /// If non-empty, indicates the names of columns from the CSV file that should
+  /// be actually read and converted (in the vector's order).
+  /// Columns not in this vector will be ignored.
+  std::vector<std::string> include_columns;
+  /// If false, columns in `include_columns` but not in the CSV file will error out.
+  /// If true, columns in `include_columns` but not in the CSV file will produce
+  /// a column of nulls (whose type is selected using `column_types`,
+  /// or null by default)
+  /// This option is ignored if `include_columns` is empty.
+  bool include_missing_columns = false;
+
+  /// User-defined timestamp parsers, using the virtual parser interface in
+  /// arrow/util/value_parsing.h. More than one parser can be specified, and
+  /// the CSV conversion logic will try parsing values starting from the
+  /// beginning of this vector. If no parsers are specified, we use the default
+  /// built-in ISO-8601 parser.
+  std::vector<std::shared_ptr<TimestampParser>> timestamp_parsers;
+
+  /// Create conversion options with default values, including conventional
+  /// values for `null_values`, `true_values` and `false_values`
+  static ConvertOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+struct ARROW_EXPORT ReadOptions {
+  // Reader options
+
+  /// Whether to use the global CPU thread pool
+  bool use_threads = true;
+
+  /// \brief Block size we request from the IO layer.
+  ///
+  /// This will determine multi-threading granularity as well as
+  /// the size of individual record batches.
+  /// Minimum valid value for block size is 1
+  int32_t block_size = 1 << 20;  // 1 MB
+
+  /// Number of header rows to skip (not including the row of column names, if any)
+  int32_t skip_rows = 0;
+
+  /// Number of rows to skip after the column names are read, if any
+  int32_t skip_rows_after_names = 0;
+
+  /// Column names for the target table.
+  /// If empty, fall back on autogenerate_column_names.
+  std::vector<std::string> column_names;
+
+  /// Whether to autogenerate column names if `column_names` is empty.
+  /// If true, column names will be of the form "f0", "f1"...
+  /// If false, column names will be read from the first CSV row after `skip_rows`.
+  bool autogenerate_column_names = false;
+
+  /// Create read options with default values
+  static ReadOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+/// \brief Quoting style for CSV writing
+enum class ARROW_EXPORT QuotingStyle {
+  /// Only enclose values in quotes which need them, because their CSV rendering can
+  /// contain quotes itself (e.g. strings or binary values)
+  Needed,
+  /// Enclose all valid values in quotes. Nulls are not quoted. May cause readers to
+  /// interpret all values as strings if schema is inferred.
+  AllValid,
+  /// Do not enclose any values in quotes. Prevents values from containing quotes ("),
+  /// cell delimiters (,) or line endings (\\r, \\n), (following RFC4180). If values
+  /// contain these characters, an error is caused when attempting to write.
+  None
+};
+
+struct ARROW_EXPORT WriteOptions {
+  /// Whether to write an initial header line with column names
+  bool include_header = true;
+
+  /// \brief Maximum number of rows processed at a time
+  ///
+  /// The CSV writer converts and writes data in batches of N rows.
+  /// This number can impact performance.
+  int32_t batch_size = 1024;
+
+  /// Field delimiter
+  char delimiter = ',';
+
+  /// \brief The string to write for null values. Quotes are not allowed in this string.
+  std::string null_string;
+
+  /// \brief IO context for writing.
+  io::IOContext io_context;
+
+  /// \brief The end of line character to use for ending rows
+  std::string eol = "\n";
+
+  /// \brief Quoting style
+  QuotingStyle quoting_style = QuotingStyle::Needed;
+
+  /// \brief Quoting style of header
+  ///
+  /// Note that `QuotingStyle::Needed` and `QuotingStyle::AllValid` have the same
+  /// effect of quoting all column names.
+  QuotingStyle quoting_header = QuotingStyle::Needed;
+
+  /// Create write options with default values
+  static WriteOptions Defaults();
+
+  /// \brief Test that all set options are valid
+  Status Validate() const;
+};
+
+}  // namespace csv
+}  // namespace arrow

shared/package-files/d1/d12b3cc66af3f42a8ebe63e1c91d24f92c6237b6a93a3702938dffabd812d77b/blob

@@ -0,0 +1,74 @@
+"""Exception classes raised by urllib.
+
+The base exception class is URLError, which inherits from OSError.  It
+doesn't define any behavior of its own, but is the base class for all
+exceptions defined in this package.
+
+HTTPError is an exception class that is also a valid HTTP response
+instance.  It behaves this way because HTTP protocol errors are valid
+responses, with a status code, headers, and a body.  In some contexts,
+an application may want to handle an exception like a regular
+response.
+"""
+import io
+import urllib.response
+
+__all__ = ['URLError', 'HTTPError', 'ContentTooShortError']
+
+
+class URLError(OSError):
+    # URLError is a sub-type of OSError, but it doesn't share any of
+    # the implementation.  need to override __init__ and __str__.
+    # It sets self.args for compatibility with other OSError
+    # subclasses, but args doesn't have the typical format with errno in
+    # slot 0 and strerror in slot 1.  This may be better than nothing.
+    def __init__(self, reason, filename=None):
+        self.args = reason,
+        self.reason = reason
+        if filename is not None:
+            self.filename = filename
+
+    def __str__(self):
+        return '<urlopen error %s>' % self.reason
+
+
+class HTTPError(URLError, urllib.response.addinfourl):
+    """Raised when HTTP error occurs, but also acts like non-error return"""
+    __super_init = urllib.response.addinfourl.__init__
+
+    def __init__(self, url, code, msg, hdrs, fp):
+        self.code = code
+        self.msg = msg
+        self.hdrs = hdrs
+        self.fp = fp
+        self.filename = url
+        if fp is None:
+            fp = io.BytesIO()
+        self.__super_init(fp, hdrs, url, code)
+
+    def __str__(self):
+        return 'HTTP Error %s: %s' % (self.code, self.msg)
+
+    def __repr__(self):
+        return '<HTTPError %s: %r>' % (self.code, self.msg)
+
+    # since URLError specifies a .reason attribute, HTTPError should also
+    #  provide this attribute. See issue13211 for discussion.
+    @property
+    def reason(self):
+        return self.msg
+
+    @property
+    def headers(self):
+        return self.hdrs
+
+    @headers.setter
+    def headers(self, headers):
+        self.hdrs = headers
+
+
+class ContentTooShortError(URLError):
+    """Exception raised when downloaded size does not match content-length."""
+    def __init__(self, message, content):
+        URLError.__init__(self, message)
+        self.content = content

shared/package-files/d1/d12c79c8bf03f29c980d74c80590284e24ac4691bf789cfcb83dadb55ae49615/blob

@@ -0,0 +1,20 @@
+8.278938049410748956e-01 9.035293984476246987e-01 1.862188994679486731e-01 8.921151312310462433e-01 2.061859119379583216e-02 3.440636727385729676e-01 1.533779912830328662e-01 5.701372300009802663e-01 5.510020730211558915e-01 1.792362258426003496e-01 8.086175120876580857e-01 6.115487184317183189e-01 1.233471787164852618e-02 1.441643531871039663e-03 4.044309209045688913e-01 3.561398959499905148e-01 1.281985712929750720e-01 8.663300833847481508e-01 8.696027786291581352e-01 3.611727370363766454e-01 5.283537658772616830e-01 1.440241088090119526e-01 3.112457227138950566e-01 6.031280796897889873e-01 9.230324792742518047e-01 2.332121881136874908e-01 3.192652267403439659e-02 3.466206294995559656e-01 2.988687728046366399e-01 5.116749542048093513e-02 2.584975830914494344e-01 4.302023478042227289e-01 8.003972751713522849e-01 9.364931911368097328e-01 9.737098649964673891e-01 4.718038453972229762e-01 4.526591686607864817e-01 1.056485678520797666e-01 5.883019714285405710e-01 3.846092237676981274e-01 6.461500053435473845e-01 1.013239729848824933e-01 1.216151561651189761e-01 5.159668929484659827e-01 8.452074473510227115e-01 9.885170962247968873e-01 7.623883073490128615e-01 2.291163243615434997e-02 5.775530980802381364e-01 7.820699896828091635e-01 8.239186345842965942e-01 3.391800105260227571e-01 9.546318451614538292e-01 3.789677917867695367e-01 4.526533399649290690e-02 8.366786473238587707e-01 3.082636811049858094e-01 1.173936820793450853e-01 7.631994969169442200e-02 2.997416650722183329e-01 5.795208655160232203e-01 3.942350892542011431e-01 1.175126383297261379e-01 4.928232513950027149e-01 9.421293996225950096e-01 8.365391053841342295e-02 6.868059693571844093e-01 3.589527962429440722e-01 7.592939427166059962e-01 5.623849466131448649e-01 2.110746828032050715e-01 9.824683704668600859e-01 2.661230142246236996e-01 6.162272315007123469e-01 5.023254536607497656e-01 5.202854476669782624e-02 5.835090668842095596e-01 7.864642118889143552e-01 2.504012386867506823e-01 6.728308641135989365e-01 4.610793534576096420e-01 4.820508770515909980e-01 9.720403251022265989e-01 3.100069285263498120e-01 7.681017126461753275e-01 7.956539306007082146e-02 2.593389637887737464e-01 1.137852590403054531e-01 3.885303073284454012e-01 8.599094660075957686e-01 5.215167875918280682e-02 1.620908248572288102e-01 1.859236090457663249e-01 6.247716512610480555e-01 3.415128495520775020e-01 7.034903368378029320e-01 6.037564640019568163e-01 2.338969434423310290e-01 1.002104885609900187e-02 7.866058403969036217e-01
+8.033694116033356369e-01 8.653264545544031572e-01 7.468340410754038539e-01 6.362430919910603278e-01 5.120006306625468628e-02 9.503348372633585450e-01 4.697732609626817935e-01 4.221305288459429317e-01 3.153452119838391354e-01 2.991014843442657556e-01 1.190667967280257811e-01 3.486567714509342109e-01 8.289493649885054660e-01 8.454811050800014049e-01 9.149673018211901265e-01 7.708707837193897738e-01 2.640157732122547785e-01 2.107897022189605396e-01 4.207633055054439408e-01 6.719500284654699174e-01 1.458031684893063007e-01 1.800412735886125493e-02 8.402733435220011149e-02 4.206760156883160295e-02 1.376933515041314227e-01 1.716717341022133692e-01 1.788220727652158892e-01 8.224310433402118869e-01 7.729093666867475898e-01 2.064223621025984556e-01 9.592092036227207741e-01 8.312490243754996344e-01 6.673289360369902834e-01 4.632847903690773261e-02 7.643954098358983762e-01 9.359341525615098023e-01 1.914966319163026176e-01 4.536590469402868031e-01 8.640836016538007147e-01 3.941529178175462444e-02 5.602101995205478469e-01 9.263806161941660067e-01 1.555995325944817820e-01 6.172208102950116348e-01 6.335576752812099866e-01 9.766975460368043649e-02 4.475795689539874278e-02 3.248842796104995934e-01 5.700377122149502540e-01 9.066962967256807504e-01 5.458460621505676347e-01 6.833401285581487405e-01 2.887244409544044155e-01 1.316338647016834784e-01 2.325673305245992140e-01 4.150121963188406760e-01 3.834845466366055833e-01 8.149365773968725302e-01 1.867003849450201702e-01 3.170322173543018707e-01 6.832093662682684476e-01 1.729728518929105618e-01 9.236557359702636250e-01 9.152941252150086360e-01 7.224879983096620384e-01 8.557920626598064517e-01 5.344883059251644974e-01 4.876873274449112783e-01 8.308277804506420949e-01 3.916624489322212410e-01 3.459695122273966916e-01 4.033512499027409604e-01 6.555726444913008155e-01 7.138452409380238173e-01 1.683937314599968094e-01 1.769382143486440961e-01 7.588683655178136700e-01 3.750589892880819010e-01 7.525176245126207197e-01 6.083961152538303052e-01 1.145972309907993258e-01 6.239614485809552580e-01 1.307655482065895880e-01 8.530458750670916190e-01 4.801602070124768584e-01 8.168122189863546989e-02 3.793139622744635675e-01 1.496986997776840189e-01 7.129023878302899186e-01 6.830979237438047358e-01 7.635375943876505644e-01 1.824004963251233402e-01 5.764695848992339444e-01 8.865113248731604223e-01 5.784337085544002388e-01 9.700026628755119562e-01 7.318207347905059112e-01 3.851401393936705331e-01 1.774291851193399161e-01 9.763423229242296220e-01
+9.287178470949695175e-01 1.748282433617460718e-01 9.238531711586964734e-01 8.291274445125006443e-01 9.513259272578692416e-01 7.486316801165745494e-01 6.257378457524477300e-01 2.062711693536473101e-01 3.970721244184766130e-01 2.738325225026445597e-01 8.735038948299954642e-01 5.415282140033768066e-01 5.176317904298315398e-01 5.347036264518250093e-01 7.482056965410627258e-01 4.140672582824351800e-01 8.709067272363142376e-01 9.499605569181273079e-01 5.380266748336398619e-01 4.369252161707162241e-01 8.235722216228258397e-03 4.308187193646527691e-01 6.030581482859224129e-01 7.316831195156517920e-01 5.540499846834291420e-01 2.044203040111662872e-01 8.645251782981867583e-01 1.816095717570278545e-01 9.639119168018674966e-01 3.572031072322333634e-01 5.580226816834680248e-01 5.586629875016585478e-01 7.213854320902782780e-01 8.513998260042524580e-01 6.308764347277173723e-02 4.299855362100638567e-01 8.789303907444128150e-01 9.178850359236285783e-01 2.275205845091231582e-01 1.899395443939643213e-01 7.103070862773533944e-01 9.450015289553428399e-01 1.691856364522159595e-01 7.368719616877857925e-01 9.600189536623833231e-01 5.128846522932454244e-01 6.209162727118655578e-02 7.992250598838029907e-01 9.141050280518014937e-01 1.471297785256820978e-01 7.466162372930541524e-01 4.656107650642931084e-01 6.399324135161845728e-01 2.023617619481610230e-01 1.019104648900100996e-01 4.390693688536728700e-02 9.822620353006089600e-01 2.881951852926285529e-01 6.191575015960482098e-02 8.989580763251467932e-01 4.635958631890454429e-01 1.781973138114967270e-02 7.906911683818984571e-02 6.525270776225711167e-02 3.620583622807886925e-01 2.651673718940715796e-01 5.829372395929610651e-01 2.118159824373908595e-01 5.900287159143694504e-01 9.405929925178391215e-01 9.262415619063500971e-01 5.639581506302312475e-01 4.529556154689695635e-02 2.873819210518682166e-01 5.718545934306838996e-01 9.877670791317306742e-01 4.120364488714320927e-01 9.896078045634184583e-01 3.796586997026456523e-01 1.178183652203194098e-01 6.641068305236120795e-01 4.045960610587706618e-03 2.262690437428437340e-01 7.839938005832693957e-01 7.695391333937223743e-01 3.713918392552509884e-01 4.245533341514018399e-01 1.475072494020331915e-01 6.011975181419888514e-01 5.158174017998343741e-01 1.788706151398071764e-01 8.880707130134481986e-01 6.463351030474082659e-01 6.499920635615744624e-01 8.570273676455353318e-01 6.055019270899113515e-01 2.123561211054603159e-02 2.027688787664126968e-01 1.930834215328548487e-01 5.131906052747271518e-01
+2.599990881903107010e-01 6.767857524909899336e-01 7.188217446352963558e-01 3.037178903357997672e-01 4.252381412838680541e-01 4.070924411439535984e-02 8.426710493038247485e-02 8.301517457289483426e-01 8.254603255702420705e-01 7.258533909453509514e-01 9.958706809470796451e-01 1.323408451651194584e-01 8.523995455245143571e-01 2.572405385832454705e-02 4.715363690065482727e-01 7.920130365690022378e-01 7.613745641534582775e-01 5.108305991695683002e-01 7.908714335912382376e-01 4.641131983754837043e-01 3.112627109831845873e-01 4.218013908715474436e-01 3.291577909008427394e-01 2.538715054071232213e-01 1.362470842487485401e-01 2.716429790290709745e-01 1.485325814161112534e-01 4.514539027544387517e-01 6.900835128673067365e-01 7.793407072946112457e-02 5.938024345270752624e-01 1.497853829906865553e-01 5.399567982652856424e-01 1.419209916759478496e-03 7.719776132867679497e-01 3.130795105576239523e-01 6.670071611167494030e-01 8.900596881158256979e-01 8.011158503301568645e-01 7.089295605187424520e-01 4.671116382997058114e-01 6.682965170673403899e-01 6.524835265739736823e-02 5.454288420771494783e-01 7.751910790556310049e-01 8.192595541387335256e-01 3.098855848167891835e-01 3.689971355659119601e-01 8.666507475054133769e-01 2.749042684253171220e-01 3.566565602478318775e-01 4.838173174723044978e-01 1.032975933616413489e-01 5.063065339610417492e-02 5.791168455729079900e-01 3.573337411289496668e-01 6.714098909652352898e-01 2.917057662433912846e-01 2.654964332620638467e-01 7.171804039048814694e-01 3.314488637898249657e-01 5.230399837442840649e-01 6.866534136026025692e-02 1.252966394621071178e-01 5.349397882659551184e-01 2.841423847455760709e-01 4.158473635710734362e-01 7.197062989831272128e-01 5.123869045047864113e-01 8.675622821594339840e-01 8.097441845042540054e-01 7.317178252133832439e-01 3.300847596465853462e-01 5.922311859141077273e-01 8.852619511417836318e-02 2.673412917259408994e-01 6.878259052441990651e-01 3.223000927116328462e-01 8.859387123976615319e-01 5.722722388300067742e-01 8.254877606669521750e-01 5.705299682290687624e-01 7.046478734972855262e-01 1.316324413616759559e-01 3.056358395675535800e-01 2.396516834600909140e-01 2.041201422493257311e-01 1.610755140653103989e-01 1.617012564641111538e-01 4.449920510036902144e-01 2.731012972755201274e-01 7.826874666257994662e-01 5.193612375350010746e-01 8.688804522977213729e-01 3.742157602758655610e-02 6.649628920608219307e-01 5.978149424619171315e-01 5.345645500553952711e-01 9.443202650415919441e-01 6.105837075491723498e-01
+6.387761328141735584e-01 4.210087412162694109e-01 3.777306694964789324e-01 3.576349403292201634e-01 7.272699618880260619e-01 9.173392803607671731e-02 1.212535698300880593e-01 3.871229381194544183e-01 7.735150198351389284e-01 4.687200483013695962e-01 5.161778571874678923e-01 9.839646447226980674e-01 8.626932748911960713e-01 9.618485576577924245e-01 2.997996427525421170e-01 3.955404657388794654e-01 8.480126027102616870e-01 8.194992325050480808e-01 2.800213436873294492e-01 7.188391466620779324e-01 2.289766105875049584e-01 3.838547514028287644e-01 1.363553401061209369e-01 2.131328253542326134e-01 2.666779468144075960e-02 3.252883844200405994e-01 4.207860197469600605e-01 2.991365385037647595e-01 9.180779845534067229e-01 8.787338732192649937e-01 5.404510999105649471e-01 1.735493827761729335e-01 7.405224640747264386e-01 3.927355563629583157e-01 3.957109873399460298e-01 1.313029813325972128e-01 6.434498219738993274e-01 7.162213694578050127e-01 6.454998257494671821e-01 3.808124530008022424e-01 2.027201015737234435e-01 6.667632842770417900e-01 1.609491052365198405e-01 1.192413785409307536e-02 4.546773323526854815e-01 7.733541911050207940e-01 3.902525737195561284e-01 4.006023779897505133e-01 5.156517815815246930e-01 6.135685498584592112e-01 7.062153114980724844e-01 5.505858882117883324e-01 3.541308807182554919e-01 5.237151122342533771e-01 5.230649229131387745e-01 1.973541027697351957e-01 7.940327858595511712e-01 9.998588700623055603e-01 3.878271015153827994e-01 4.455006584967207139e-01 8.376414508056347907e-01 3.310833863524501597e-01 8.020469097392601832e-01 1.890327633084128989e-01 3.830289472395409511e-01 8.605040171046141051e-02 9.978185524023941433e-01 8.333890591892906263e-01 4.509013468741837061e-01 6.355778557686052599e-01 1.422515991097305088e-01 9.549891485963732940e-01 7.535776302868563148e-01 9.306005301880662106e-01 2.444330347211679522e-01 5.828218427569508142e-01 1.261938242968304591e-01 2.829188731405173352e-01 8.100246952078660190e-01 2.032739130996042975e-01 3.997268448390065565e-01 3.882777703107541667e-01 1.102505652624736765e-01 5.826634725328041498e-01 6.508734477956333864e-01 1.777287661702166011e-01 4.857051012052149286e-02 6.850537712379254351e-01 5.012281307761055071e-01 3.329154880061502286e-01 5.006261767216675374e-01 4.542081454976160115e-01 6.777801995399822532e-01 4.271303586474960445e-01 7.820470659692947413e-01 5.143462618485082904e-01 4.071273891563575997e-02 8.503383643856671226e-01 6.877485768345151795e-01 6.498843855014626580e-01
+5.539512747016193117e-01 6.329206647391879548e-01 2.798533500321682688e-01 4.825977295850051307e-01 7.625297023172977751e-01 9.081309101427640362e-01 4.124792086535029600e-01 3.647019658319609059e-01 7.529595202332928228e-02 3.072404010876803593e-01 7.890673660964639957e-01 4.079781478915127657e-01 1.440519120695739064e-01 2.538968953804546791e-01 1.595028243568367143e-01 9.066545851872198636e-02 6.367601114674349416e-01 7.622263643880089479e-02 3.015728236404162654e-01 2.424070469873378375e-01 5.711440390241000475e-01 5.717001375511508998e-01 2.237853674032181939e-01 7.112101625753678436e-01 4.321054197012103026e-01 2.505322169010260058e-02 5.877307077139551916e-01 4.415771174397812304e-01 3.766022855145171322e-01 9.803490652619811785e-01 1.229258314111529860e-01 8.108351868714478439e-01 8.558595456964329662e-01 2.168217533833206589e-01 2.034022719386595623e-01 8.687457137579783772e-01 9.013327195854559104e-01 8.156766512673154779e-01 2.717576187546973943e-01 1.756417893371479133e-01 7.555856977566548505e-01 6.708809351312817748e-01 8.998789237886926085e-01 1.936367585946979775e-01 7.949724635465026390e-01 3.164799312763589834e-01 5.493048513173155456e-01 1.608917269168268493e-01 3.048667492191803330e-01 5.599401537727016764e-01 5.779501360842279611e-01 1.296714605309662316e-01 9.160752328055997706e-01 8.058674476110374574e-01 4.385508937505578908e-01 9.212419718012100356e-01 2.249887451242467140e-01 6.283927745352599903e-01 3.778992451536005159e-01 3.571958698867505611e-03 7.276526470528231760e-01 9.051678673805297892e-01 8.465837072484881931e-01 4.548317505393462135e-02 3.189318261926020748e-01 4.446388607398673587e-01 4.292356336344156365e-01 4.203980977718795309e-01 4.698059253071955599e-01 6.151991200848159203e-01 8.479986139404802614e-01 9.870993262459623052e-01 3.164206525899861955e-01 6.464672171639846976e-01 8.508781429592480183e-01 4.733667503354813677e-01 8.076014176740163863e-01 6.671443255679101458e-01 6.639213267047979761e-01 3.681688930741919830e-01 4.679870252651611162e-01 1.790041740686979521e-01 8.446070273663058847e-01 3.350737544979878191e-01 6.600272349677447359e-01 4.356083218487936115e-01 7.995134167346013010e-01 9.083660261041469619e-01 9.743975306734570241e-01 8.144839650654719376e-01 6.865011984586443239e-01 1.709747281999153268e-01 8.534933687161740945e-01 9.494753729726415070e-01 8.140124992294850426e-01 8.936241255316055287e-01 9.087976860818796077e-01 9.030687493451383663e-02 4.025785149840914734e-01 9.592005611533803711e-01
+5.714058727476275523e-01 7.913573761505965365e-02 9.301773447377043036e-01 4.302822433307075256e-01 4.618892554175407783e-01 1.882471300213742760e-01 6.231472878215863487e-01 2.350437450940777717e-01 8.483410480771292894e-01 8.580803842040533036e-01 4.246398783388435350e-01 5.667321565946502604e-01 7.247417018955526480e-02 5.373984417482219333e-01 8.794242091541510931e-01 9.699025554453030162e-01 8.254197752548814160e-01 7.739723972867470492e-01 6.365819416181199841e-01 3.451230687021222820e-02 1.829102490094791644e-02 9.179618383026147965e-01 4.481667270072077214e-01 4.771270250445739380e-01 1.588469404953456454e-01 3.766332499200618633e-01 5.057026248713025751e-02 9.125900914275182352e-01 8.438133644246305076e-01 3.282972411719701222e-01 6.042003956122835584e-01 7.423456085393266290e-01 1.389012737541106546e-02 3.674754266702850991e-02 2.126646727703802586e-01 3.085666164246750887e-01 4.303440338750976757e-01 1.749037978865556342e-01 2.177699993322510519e-01 6.675614739991906355e-01 1.926533336347433512e-01 8.032010572660308600e-01 4.611412981769049679e-01 9.907201268457492827e-01 8.973785930837320235e-01 6.286342392657409128e-01 8.111266245859546364e-01 1.154230969025437092e-01 8.382880466301794176e-01 1.053753927827069115e-01 9.921712862234919328e-01 9.041662667920956631e-01 3.626267376021269362e-01 2.262225368932846425e-02 8.669003741626111204e-01 7.597054897704164089e-01 4.700318514995387442e-01 4.338185014241978665e-01 1.205425463362067573e-01 2.413879270602589111e-01 5.483334840461459025e-01 2.042653841254596925e-01 5.452588940366013270e-01 3.164646091706100339e-01 1.878958248945691301e-01 2.188622304737641855e-01 2.970982599823450698e-01 5.952148400199362976e-01 9.614251220149501176e-01 5.446813400697393392e-01 5.900748097930779146e-01 2.653062526715309621e-01 5.459933097767216692e-01 3.174185404661935550e-01 1.412133354129242457e-01 1.487441669790685594e-01 3.953776242211952674e-01 5.274261039692862418e-01 1.756132307607755072e-01 4.481942852746899630e-01 6.390660088765629521e-01 2.860380430081067571e-01 5.866902519902850166e-03 3.026687645174785946e-02 1.952533570196290924e-01 2.154769096186736066e-01 8.920573593276575064e-01 5.644513191915436767e-01 5.551464696654353492e-01 4.378199413349500579e-01 8.685737643974280608e-01 7.493934764293597173e-02 9.556749726352036234e-01 6.386433482536227890e-01 8.714694524097754691e-02 1.722786161701279628e-01 6.526867532768643176e-01 8.950304705281527662e-01 6.158198776753203152e-01 9.587176904005377809e-01
+7.705718397401561948e-01 3.165816092999733655e-01 4.334200859975760878e-01 8.639807015515663657e-01 5.576514209532534849e-03 2.456745447057938625e-01 1.664686313299922338e-01 9.637084729617834133e-01 1.083448720752323569e-01 1.865218070380464388e-01 3.730358890475884426e-01 5.015351872138350542e-01 7.420710795841709562e-01 4.919420674769692248e-01 3.426558201886464872e-02 8.669984854934246199e-01 2.204243734202966376e-01 4.109792246853891662e-01 4.361732572946559472e-01 6.819306998053020763e-02 9.986304248057148447e-01 4.119289455392274313e-01 8.533050041845835487e-01 3.416914861912183632e-01 6.522191951039880697e-01 4.162803668786793088e-01 9.051674379917418189e-02 4.552378661306888397e-02 2.122677193466918633e-01 7.461518531655018105e-01 4.654688019259497489e-01 7.877564083548750373e-01 4.518328005682387127e-01 7.173857464237374248e-01 6.940056370290903498e-02 2.804574410412373764e-01 6.095681113112718652e-01 3.680596478602831123e-01 1.814569150719304025e-01 6.505055517979729807e-01 2.759585245701871026e-01 1.429501104786028431e-01 7.813891153083207808e-02 8.925314279991185540e-01 6.692056941902108091e-01 1.915141341107173822e-01 5.750233129581091562e-01 2.051961006251528108e-01 3.849013692629975614e-01 9.503788222043518807e-01 7.690419386411734282e-01 9.978147530014782607e-01 1.719584162437415298e-01 4.890758882401113894e-01 7.195660736040896399e-01 2.485818040997200828e-01 9.706486601870933928e-01 5.182604282071262558e-01 8.082072245463804983e-01 4.889961284821118248e-01 8.042893959057633158e-01 3.200685313413229593e-01 8.983245016887355661e-01 2.811495336955205371e-01 3.986095833814048417e-01 8.607229214132059436e-01 4.827620119717191960e-01 6.715610252037491623e-01 9.330824374137768329e-01 7.537710530085762750e-01 9.840804224010484269e-01 2.319352541177217564e-01 9.569114943157627229e-01 5.821928104654411351e-01 6.700479524814679788e-01 5.663434680086896211e-01 8.851091082101365526e-01 6.800562815862243315e-01 3.578475213752868589e-01 2.900164669281133367e-01 8.379170683569914235e-02 9.929972839740475177e-02 5.946248553621906741e-01 1.991332889320840405e-01 8.115065723822508792e-01 2.023388190440008616e-01 4.056545651129230823e-01 2.966825350250481552e-01 7.457176343507545546e-01 9.856015771246517954e-01 2.264338016147812160e-01 8.366528670045663141e-01 6.116829813603242849e-01 2.605933184296719274e-01 5.765962146558850643e-01 5.064075092266390188e-01 5.499615769589756287e-01 9.240234698632640020e-01 7.169900155229913530e-02 3.544181364560751168e-01
+8.154844535553099627e-01 4.797965609394789777e-01 7.476703385713100447e-01 9.086708404761600910e-01 3.191752505450355937e-01 7.611128630021511965e-01 6.246790343299296611e-01 1.942001426217137006e-01 2.789860414631386565e-01 3.236359785042408621e-02 3.178191288741717413e-01 8.372264298357038337e-01 8.872692914664047636e-01 9.589758852077276963e-01 3.123722260380168425e-01 8.980164015338999439e-01 7.260784140459818348e-01 6.567013512265649222e-01 1.028743505926521529e-01 6.821705410750319443e-01 6.889838995316139858e-01 5.587525493094736007e-02 6.921487028366646310e-01 3.616312929861494885e-01 1.673758008792780583e-01 6.626504595920326146e-01 9.125680913222075086e-01 1.424077784972291871e-01 6.508496429060767197e-01 6.615417385775157477e-01 9.654167310675311198e-01 5.536662974550183858e-01 7.092622144968085962e-03 6.694595400455760625e-01 1.828533619119211417e-01 3.421514408394116247e-01 1.242580151818144518e-01 9.888774797458224075e-01 9.777955172739735135e-01 4.271370765628749178e-01 1.211608384809655936e-01 1.580132417172936954e-01 3.242705395708289640e-01 3.268994391754735940e-01 5.213767653645562383e-03 4.475169480357120699e-01 9.593245219293577986e-01 6.994304536782350867e-01 7.063863152769014331e-01 8.381620829497931080e-01 2.760441799736219615e-01 3.755200946645842475e-01 3.627729621737311172e-01 9.518310606719182498e-01 3.577273025276901386e-01 3.991159901003488164e-01 4.187060513068554535e-01 7.422605403637314581e-01 6.697944269780702342e-01 6.020599837037767799e-01 1.571185850817550245e-01 7.519860911185742847e-01 6.635775704496444938e-01 9.487848173531471252e-01 7.900030232338028924e-01 4.143783957270819052e-01 5.618429740858444932e-01 3.737804619062014000e-01 6.179941187802344693e-01 6.553638605616040058e-01 1.009709416658691739e-01 4.935037098582963910e-01 5.485489972455533936e-01 1.024147956480448984e-01 1.195764707555347917e-01 4.910516327810896531e-01 3.551185778630389089e-01 3.857601645798814927e-01 2.074975219600547760e-01 2.084038664460790002e-01 5.268616653491025037e-01 6.948014877618717833e-01 6.179744044618615817e-01 7.063658085955483168e-01 7.925757227686872630e-01 6.199016959584816577e-01 1.163676037434490107e-01 7.425752264755586252e-01 5.403115665133301215e-01 2.546191951391015840e-01 6.961300925345208501e-01 4.003013072125547467e-01 5.906120962720950995e-02 5.879915846330325824e-01 1.213602408288709800e-01 3.801780679842765576e-01 1.731477742402802722e-01 4.624568816669496485e-01 3.304453744619206823e-01 8.810445876116090869e-02
+5.140190515373614932e-01 1.419225260054487459e-01 7.777845802285945354e-01 3.327562899409282071e-01 8.916875699762913943e-01 7.212852862736146564e-01 5.727327199433507321e-01 5.897820225918504189e-01 7.318614954542906892e-01 7.393985144455500480e-01 4.531340740296823100e-01 9.903061584426188224e-01 4.213350938331624773e-01 4.542342471963995987e-01 9.788786426453045530e-01 1.881707000343846303e-02 8.005433413647761176e-01 1.523502822273363755e-01 5.630164732287495921e-01 5.946603842470724599e-01 1.225547698678740582e-01 1.531136594724622491e-01 8.157973612638946825e-02 2.752046015644330490e-01 6.809045821946161370e-01 6.455289724528190387e-01 3.830356726830793646e-01 4.446144649678575034e-01 4.969038423960672191e-01 5.497873820641221432e-01 9.471879627821714331e-01 5.933046675329255448e-01 4.099233758501530378e-02 5.790409810134594659e-01 9.546095885251496549e-01 2.608616052375664074e-01 6.910160339170060562e-01 1.293709850476291168e-01 6.407264616302255078e-03 6.186037089828009261e-01 5.537861302543241049e-01 3.527421038298221845e-01 8.033232052121624944e-01 8.128114152830284711e-01 8.319982582278713235e-01 5.939566376046836460e-01 2.291090283499520597e-01 5.438101817725821130e-01 6.881146379117278888e-01 2.421968586304659166e-01 5.874047918543783275e-01 6.210102709484541794e-01 7.041387566450251212e-01 6.959223476278774134e-01 9.133877300988062498e-01 9.230647706207778525e-01 6.856884219815310155e-01 6.997988808693775820e-01 6.177944932528769417e-01 5.512902545683161515e-01 5.818280341729102911e-01 6.538267999985679646e-01 6.946673485935980219e-01 4.817938258357623571e-02 9.352008817207906333e-01 4.774162142215661042e-01 5.768063588692976529e-01 4.589648891483899540e-02 7.998946815651652997e-01 4.434260476954369201e-01 9.850053510925722566e-01 6.648626681529369309e-01 4.606293826856903140e-01 3.309042418210563774e-01 1.438901922508034614e-01 7.986559119276418484e-01 7.037818421334554042e-01 3.605119534240813772e-01 3.785959549258922641e-01 9.562491516841659100e-01 4.997955143590974147e-01 1.029540300938682762e-01 1.819017177001992502e-01 3.665425750262368831e-01 1.688063588370778412e-01 7.030735208313992901e-01 8.922375654244527610e-01 1.055706412056253152e-01 2.664739907746691561e-01 9.906029568647586325e-01 6.043845090140997911e-03 3.495786295043534775e-01 5.989441999519146131e-01 6.776147193866479679e-01 7.012991789852640601e-01 1.825838783477321536e-01 7.612293578749116385e-01 1.564769891240175292e-01 2.762157292905387251e-01 7.641900040015234818e-01
+4.746013333880729768e-01 7.609202966712714788e-01 2.537820854162747830e-01 1.709362234877408460e-01 1.886635378734374813e-01 2.439567014093724229e-02 7.640304718272151741e-01 3.483216170435471382e-01 7.744289278738043514e-01 4.190437573644867353e-01 5.319091476394965934e-02 8.580130976087452233e-01 6.259446446786639529e-01 8.793213970773006150e-01 2.441023074890465994e-01 7.753405549489799098e-01 8.760187573193888300e-01 5.946480724009295393e-02 2.873093046571124631e-01 8.710837851946537924e-01 9.103181731924696596e-01 6.534637257615111272e-01 4.128420398577182793e-01 4.905858108576378607e-01 6.178275806701372108e-02 6.368043900016381320e-01 2.865296941219959148e-01 6.371773028539067241e-01 4.924322796636745325e-01 1.709313290387282080e-01 1.856892551689268700e-01 9.592782603102242289e-01 5.402593764193130976e-02 7.287312244390512506e-01 5.679467572000697073e-01 6.255587794305905724e-02 3.069660218141317953e-01 1.089960430557104232e-01 5.550748245336984965e-01 2.555948886689661803e-01 4.140925514039996980e-01 1.180376445052062628e-01 8.832322629884041820e-01 7.784546946701487169e-02 3.177678935473182698e-01 6.681804863429485764e-02 7.047099396645268854e-01 4.133897376851528582e-01 5.600656990480865627e-01 3.883995683475501837e-01 4.459430113152932362e-01 4.214077227574740681e-01 4.763369230200156235e-01 2.701480661168440545e-01 4.296286564389811824e-01 9.601402258758658936e-01 6.326999441846863359e-01 2.442086919688498670e-01 8.407708423957936938e-01 3.626867985638081437e-01 3.641441713291436733e-01 7.932397565989488530e-01 8.902073520619256941e-01 1.929173010337000838e-01 7.309376779324568973e-01 7.305852858337777977e-01 6.510197444582447313e-01 9.512661608643838695e-01 8.461467164366111016e-01 9.245490147941206605e-01 2.658844813385705663e-01 9.538758859344749208e-01 8.215517204998477041e-01 8.217795540390903097e-01 7.569662091300560780e-01 6.262685322871274218e-01 5.597770510574888725e-01 8.155720175123675197e-01 8.545688745180864965e-01 8.986051518529034610e-01 2.477911506572628708e-01 8.462580108996445860e-01 6.065941220995090255e-01 6.500490804973033665e-01 1.120463882674053169e-01 9.299049132942927010e-02 1.388364074229719858e-02 5.901199124540731367e-01 2.795110110544174464e-02 1.644097083463245124e-01 5.341029647603202646e-01 5.276816677181681570e-01 5.439849107754858304e-01 5.371677986392331405e-02 4.515163125788429488e-01 5.036243367087100964e-01 5.721818679625961801e-01 5.271368612400184617e-03 7.720961020546839304e-01 9.015383457479009266e-01
+8.301526916287945701e-01 8.704609696144033348e-01 2.955689129581380303e-01 1.762209253489944727e-01 2.698172933050072553e-01 1.138095349991521399e-01 4.092588531860634760e-01 8.202978121681584467e-01 2.822241377079557356e-01 6.117376205659387223e-01 7.169923068016897938e-01 9.310256256264415331e-02 3.989664052931106708e-01 1.651874953308862803e-02 7.890202597932294282e-02 9.068686774810821305e-01 5.203866694486933842e-01 4.297748572844445336e-01 5.208786995443430712e-01 2.163224881365530816e-01 7.274307306357226111e-01 1.675784956180090823e-01 5.969822786565782691e-01 8.959750832846602453e-02 1.253794151891943764e-01 5.352628522116801291e-01 2.562706125890066300e-01 6.030433202137867044e-01 8.330717547440393833e-01 9.603613683422040914e-02 7.569714244468559450e-01 3.184801677796517128e-01 1.667069341164499896e-01 3.132470247801235619e-01 6.417752836394801097e-01 6.433909425912354152e-02 4.056860213146201710e-01 3.166772891331335327e-01 9.574059746098845247e-01 1.492907964460536974e-01 8.311513764927496162e-01 6.652928354977717396e-01 2.396804722185036374e-01 5.812361618600220270e-01 9.724228681350225445e-01 2.853983236378453414e-01 5.337719354896472979e-01 6.779446197712412081e-01 5.485102006140557540e-01 9.010109155962182648e-01 5.724439967467525037e-01 5.965540527411405947e-01 1.598667990086183321e-01 1.363934512727023041e-01 5.327536522697270405e-01 4.123866715061276222e-01 4.617251396918636841e-01 6.935944951381239898e-01 4.300337419593377453e-01 1.892407993760835128e-01 1.666936825594794724e-01 4.625634184864588772e-01 4.805197636774838355e-02 7.003542850133466224e-01 2.130226006716084974e-03 8.678863343041013367e-01 4.874478520451258623e-01 7.043560228741558848e-01 6.317719270475393722e-01 5.372392256296196766e-01 2.982649812986511995e-01 1.272558612133412037e-01 2.467337555730741983e-01 6.546893200021091097e-01 6.291921159383098150e-01 8.505920470407707379e-01 4.046520490181828578e-01 3.875732096593392795e-01 8.551517214319142024e-01 4.152602284179877090e-01 9.587779137989138611e-01 6.977437468944928112e-01 3.240620775541913634e-02 4.025873770391376061e-01 5.485549335619134270e-01 7.146066156157020455e-01 3.012702534568838519e-01 3.526414480395153594e-01 3.309707144485515284e-01 4.315687014460974913e-01 6.641934530697197747e-01 2.172886798352815507e-01 4.807480925564590057e-01 5.006795397998469177e-01 5.818100901154411586e-01 2.107716091585690732e-01 6.606606051140029301e-01 9.317629042790995797e-01 9.840326342340242061e-01 5.752000964817773898e-01
+9.843444595454536872e-01 1.339523968066913540e-02 6.082172659959028671e-03 7.828244785439336662e-01 5.069653703872761819e-01 2.804896494365415327e-01 2.112385836660957139e-02 6.016479440778699228e-02 7.457477935084961818e-01 3.445503949245375397e-01 4.063494277166557200e-01 8.630275274433116817e-01 5.948396018456146850e-01 1.400867933474212457e-01 6.997522422654076646e-01 5.766519767930851081e-01 5.419976500582250889e-01 7.474121304089603735e-01 2.951600193008566686e-01 7.980170422334191827e-01 1.829036799578199757e-01 6.317636496261300749e-01 2.812612231140887431e-02 5.464747656105657381e-01 3.909873503320924204e-01 4.940850205957293406e-01 8.157850130814222611e-01 5.111092739445756150e-01 9.336823640685747439e-01 7.157105167170837445e-01 7.778989455994214097e-01 1.398722535910470466e-01 5.642653936300449091e-01 3.218717164845980028e-01 9.717427501967056402e-01 3.665791984428700134e-01 3.874321311211759156e-02 9.437600858738082188e-02 5.679526822961932231e-01 5.141385991358327079e-01 7.497840799582222715e-02 5.736515309094968318e-01 1.928132849879083954e-01 6.924244068001785823e-01 1.748389677952593146e-01 4.469577663506929532e-01 1.738527450963387455e-01 7.195287763517190793e-01 8.861150811892871682e-01 1.058443750714600506e-01 1.941789362229970894e-01 9.188374820700584422e-02 7.706736301449305104e-01 6.718642548609364828e-01 5.981029087121966237e-01 4.832880127232569434e-01 3.073688779938709148e-01 5.156312334804930009e-01 1.777418420119527553e-01 8.885462205165685079e-01 4.486254681289014723e-02 1.345398129556140132e-01 7.467627984379916484e-01 4.384565546058830643e-01 7.217750080760946263e-01 3.949550352625393890e-01 4.307950907642028593e-01 6.087680934849041270e-01 3.294516167246774874e-01 1.316682090209408962e-01 1.824857738754404046e-01 5.332379826483617524e-01 3.567136182864261151e-02 1.976220743086236631e-01 5.849349042822560296e-01 1.133174406357483344e-01 7.711522754393199675e-01 8.557306786807005183e-01 3.038353471344266143e-01 4.422747047768413875e-01 2.537160404215925702e-01 2.372714099723788328e-01 5.906462765375103396e-01 4.849909323133470007e-01 2.692576210504484813e-01 4.540849506602829821e-01 9.664935719107857759e-01 2.044371576459835804e-01 4.505417469690352616e-01 7.110722322201217249e-01 3.051357995214963870e-01 8.978937034341526457e-01 6.090501112506481185e-01 6.595415779178889215e-01 6.565426836745864581e-01 6.565608489824376059e-01 2.679102664248229626e-01 3.819533138204529443e-01 6.609794961162380744e-01 2.289558446859882856e-01
+9.274935298374649140e-01 1.174096651033715855e-01 3.030761852629033637e-01 1.605508209527917174e-01 9.601854834873225775e-01 4.341959513718630648e-01 6.320768160802121560e-01 4.213429090614078110e-01 3.695553969042019160e-01 5.965457437116089556e-01 3.520335041155040479e-01 7.702703502247409961e-01 8.571112772962534709e-01 7.904077282532658844e-01 2.247339318352784554e-01 6.823720204503556097e-01 5.883435710582129996e-02 6.786037033312407596e-01 9.721137137641507886e-01 2.042576970668320557e-01 8.394085754806240862e-01 7.433082729552867862e-01 4.072614159870893147e-01 7.451483066617257123e-01 1.699472962789440045e-01 1.753052015584344314e-01 2.255269204788400428e-01 7.794755643807432799e-01 8.407732260470973662e-01 9.301182862857163558e-01 3.701995309382508648e-01 4.481909027604019657e-01 1.261889085033987001e-01 5.600591735875248833e-01 8.244692493969552061e-01 8.969188061645969601e-01 4.802217973423368313e-01 3.556164122713412201e-02 3.393317823164623270e-01 2.491242957582864292e-01 9.863253789366602797e-01 5.585415885291432625e-01 3.702350606362231344e-01 6.766101432620400535e-01 6.999259389475386284e-01 6.676108316872160220e-01 7.870681827507105544e-01 8.746765411259082024e-01 9.125268371282718727e-01 6.638849997061806452e-01 3.253268113800632522e-01 7.968625619248901337e-01 7.584122525443606211e-01 9.028886850768532701e-01 5.381622293189292083e-02 8.097562873320752752e-01 7.092942088208666895e-01 9.915538877968065323e-01 4.319294903327922652e-01 4.307127933969153721e-01 2.768507739641907772e-01 8.076253078288621046e-01 2.569233696442670967e-01 7.595893829724666979e-01 5.768081727897018673e-01 2.537536777625452045e-01 8.874419624636734616e-01 5.091705681832693342e-01 4.811826624992353585e-01 2.794462461940371290e-01 3.846927898276129021e-01 5.129562951959991679e-01 8.515004062224775794e-01 7.103144978683579858e-01 9.526388607201888847e-01 2.367905569592337889e-01 9.137336039323161740e-01 5.722969943101696710e-02 2.019723935481291255e-01 3.098764675203513619e-02 1.121146613918624357e-01 9.937693067724532314e-01 8.476717958861412772e-02 2.059652110343795917e-01 2.139791918759540446e-01 9.137860316709250919e-01 9.530862653366889425e-03 2.027843281683039400e-03 2.506229951837134484e-01 6.244523528392044165e-01 5.523937894075592325e-01 3.712168074031840792e-01 4.218847794299319665e-01 4.827576239387890711e-01 5.244634168840578425e-01 5.182241092381567604e-01 3.308639956263292881e-03 9.370528021570383448e-01 4.694554875029453012e-01 4.950447554541728135e-01
+1.525818111800841814e-01 4.708012184002630107e-02 3.899035965341954846e-01 3.928304521031263929e-01 5.602286661727436945e-01 9.738256658043862313e-01 9.404465779766183475e-01 5.750862754958349088e-01 9.547546956257608741e-01 2.750275291553152535e-01 1.682773435862793265e-01 5.865928471016079726e-04 8.543378154943809255e-01 3.547649971465383079e-01 5.058056647397523031e-01 9.116332486700751137e-02 7.534666421106954726e-01 3.082429494433007733e-01 4.527145111847344916e-01 5.456680635225539255e-01 2.504131242494785914e-01 2.509240770568589296e-01 3.949236999582302898e-01 8.782959620323271821e-03 2.474641132111736752e-01 8.229417958971670943e-01 3.444225768479134420e-01 4.000027489436257522e-01 4.247741954177396417e-01 2.497745404169693373e-02 4.325768602588443423e-01 7.336592463477830117e-01 7.667663267650381975e-02 4.179022553581047683e-01 8.745172741480690126e-01 9.417705509525042817e-02 2.807522782799587446e-01 8.212710101351362590e-01 2.211181944001613386e-01 4.319929503523877168e-01 1.858636923768219873e-02 6.737037795085246694e-01 7.997187114913413275e-01 2.976552505976116647e-01 3.272347030789168887e-01 5.550935453236346406e-01 9.224109746648162522e-01 3.192827922106745708e-01 3.500098324549234530e-01 7.821988386980260888e-01 4.478417135239194380e-01 1.580956175222456572e-01 5.300807813550156844e-01 5.806154798468634581e-01 9.456842911054151868e-01 7.688127895655872956e-01 8.456527833650537840e-01 1.784229089865225770e-01 8.114517450321339087e-01 8.062506298824222428e-01 2.113482500442499523e-01 2.629226789210241666e-01 6.478686221690072022e-01 6.006672861605766300e-02 7.013679843242253131e-01 8.784753961212666828e-01 3.487138165323044880e-02 4.928426758517070461e-01 5.976224683315064512e-01 7.629063997052759616e-01 2.761721278953045422e-01 7.240740503283805696e-01 6.131065729985127888e-01 1.630885615792579957e-01 8.473783868551159060e-01 8.347614542399306448e-02 8.137265626844719657e-01 8.512508664918938539e-01 2.777097816703766320e-01 1.729154355214796990e-01 2.203382750835449766e-01 6.134780912629795857e-01 3.524352564238901753e-01 5.370314860129862256e-01 8.013986113284543578e-02 2.555842138998117852e-01 6.553915758947851389e-01 9.679125599178584061e-01 2.549566319678178150e-01 4.008180804370896633e-01 9.145789951670967310e-01 2.787926039163850511e-01 8.599455912576436933e-02 9.637558000691170967e-02 8.274101203974880692e-01 1.803747268179315411e-01 2.175735407836230095e-01 7.825994939720237742e-01 7.928519890958951599e-02 8.707949373106749213e-01
+6.398420210047787160e-01 5.739624494012524059e-01 3.359672805578653998e-01 1.130399363175038641e-02 3.349439685346782269e-01 2.315484030880912147e-01 4.575228302577399875e-01 1.149494135594463229e-01 2.888244352925943836e-01 3.625470995156252485e-01 3.795973190611611203e-01 6.567047810450010736e-01 1.484039742710284715e-01 9.273251916560719676e-01 4.334256728976307871e-01 6.734771102219323513e-01 9.125080197222198430e-01 4.974393931097168542e-01 8.301481563280355136e-01 4.526450714147856047e-01 2.414236092573898151e-01 8.070129698367667359e-02 7.260400697427102923e-01 1.396509691839398215e-02 2.496450588391967429e-01 4.335741205447194435e-01 3.089314419194891803e-01 9.543503534526003307e-01 5.457977547458532364e-01 3.139663643587058406e-01 5.034762326753475792e-01 4.756788330475764104e-01 6.849334942793482428e-01 3.880666613022351052e-01 6.483446580176778218e-01 5.217503801099343530e-01 5.371145824070304720e-01 3.121260159429154468e-01 8.314121854062171968e-01 4.538695969561833410e-01 8.598896961203845724e-01 9.961993522734106099e-01 8.865717795946430613e-01 7.828987966783660379e-01 3.412415531643435695e-01 7.421170530151157685e-01 4.484104178639959359e-01 6.793217012099640462e-01 3.756179958191659951e-01 7.821287098222597933e-01 6.227726265188193722e-02 8.552983413221663112e-01 4.824668768009222619e-01 2.241531065858231031e-01 4.939536577599041856e-01 5.129566641128722182e-01 1.057984177672518511e-01 9.541452507300716146e-01 3.396646181755047511e-01 7.452588103611947901e-01 5.315559265659929311e-01 5.493475179850665358e-01 5.214824278139198466e-01 5.150075718147916204e-01 1.196075368500321146e-01 9.035665331176232495e-01 7.522653903639873185e-01 6.638708679914825384e-01 5.584174553800479446e-01 5.015819402508836511e-01 5.507698483308445248e-01 5.978677577011723976e-01 8.450418028759657529e-01 3.266677322748618995e-01 1.321610045897971819e-01 2.394354042746985600e-01 2.723972163557076831e-01 5.523301747352814539e-01 5.518043850608547185e-01 5.283968096837132755e-02 8.192733312104071297e-01 2.277106024970321219e-02 1.414998099027269252e-01 6.517281615256080851e-01 1.811694734825117781e-01 9.472370614713256920e-01 5.454497319021770485e-01 1.364119913158231556e-01 8.446142008509562871e-01 7.671725984742419069e-01 2.461161648406858804e-01 1.421724627107351369e-01 6.290652581179481118e-01 7.094144689448004248e-01 4.419656923472803367e-02 6.614741876652251440e-01 8.712193265403500586e-02 4.734931280852430202e-01 5.382037050480286133e-01 1.396459758005891283e-01
+9.709329844415439670e-01 8.998575745276288229e-01 9.151313462895852568e-01 6.920489275523904471e-01 2.892231405199537919e-01 6.750679746268205550e-01 5.515642485826798280e-01 1.065253097812824956e-01 2.957026803465776510e-01 8.937347659632134400e-01 9.800016515925590310e-01 7.745900896182087436e-01 1.570977683146633774e-01 1.482028765821026273e-01 2.111147779712029271e-01 9.683759902485811200e-01 6.550951580826911425e-01 8.728324682592377703e-01 5.044803166579884257e-01 8.285704754811143991e-01 1.693574499337324735e-02 6.032669995180495182e-02 1.687026879086964692e-01 7.701554026145973619e-01 1.429888016593102718e-01 5.881172815379975827e-02 9.704206919487038396e-01 4.450807650730836951e-01 1.597445784258376689e-01 9.849229394397314152e-01 4.220083573536804744e-01 9.357693600374825671e-01 2.313199262338369033e-01 4.556443403861323294e-01 2.590791012828855822e-01 8.438664994487065085e-01 5.519045677502344427e-01 4.702170125676508050e-01 6.814723205638187897e-01 7.418295483665861001e-01 3.684921032028853904e-01 1.501895844844561845e-01 4.214513377519605308e-01 8.600279963652578408e-01 6.625616611189292238e-01 5.200151456470966105e-01 7.881072743086801058e-01 2.771703241081423519e-01 9.034135930616548071e-01 5.848441705791300738e-01 8.341698181274771473e-01 1.966638677318299777e-01 7.059747894371543042e-01 7.013854316067694716e-01 1.828430942760242983e-01 4.745548949934464966e-01 6.306422394641082452e-01 7.760751707194470939e-01 9.813187212598396547e-01 2.293595795266353266e-01 7.749261876107090830e-01 2.384106107787011819e-01 9.721209688979495223e-01 2.715569353686980714e-01 2.915573577694993146e-01 3.579601509630966349e-01 3.085697512342830962e-01 4.070219981627976047e-01 1.989632411372218579e-01 7.330003339460906542e-01 5.397259604481572381e-01 6.931009942216573849e-01 1.385457419653816080e-01 1.140339999976658358e-01 3.980752590866034613e-01 9.471822621683767540e-01 5.476643721405823895e-01 6.824131903515884279e-02 5.844099130744569992e-01 2.346881692012994236e-01 9.436439228519653000e-01 4.855518260479008141e-02 8.157036123302675579e-01 1.169761256455048581e-01 5.532962903488753970e-01 1.100965596251435308e-01 9.789490602992410029e-01 8.433487462016989733e-01 1.272410782852178013e-01 2.885715258680641160e-01 7.990943955388217779e-01 1.565305358979097727e-01 9.160846960406943129e-02 8.521842244411678147e-01 4.474243106736998099e-01 3.843945818845087015e-01 4.710645906071458944e-01 2.398348154123419729e-01 6.435351435258193087e-01 7.656897921129046658e-01
+4.894328120406804539e-01 7.881019629214267574e-01 6.974585354155089512e-01 2.023858939857701156e-01 1.660984914264745926e-01 4.854517801734643534e-01 2.789848572630315715e-01 2.311636522410289718e-01 9.821076233980715608e-01 1.220641257408076052e-01 2.614036146663852866e-01 7.657560715165320220e-01 3.968360577545695378e-01 4.566023622802184434e-02 1.049701948619241598e-02 9.281162949127452766e-01 4.490137965769909201e-01 2.095846458383606725e-01 9.195504656719085679e-01 9.683515436855471004e-01 9.800174878114910060e-01 5.517610861380117804e-01 6.711570559348770670e-01 5.125258050287277989e-01 2.105581493613526423e-01 8.281813206544574868e-01 4.964783994807770995e-01 7.284974208756571645e-01 1.320629592816270348e-01 6.652194518096135045e-01 9.430156297917950958e-01 7.477263137894260003e-01 2.054087806450300979e-01 4.248209124837907247e-01 7.657518666018259257e-02 1.031614100713345028e-01 4.122242287567021712e-01 4.919658859336810686e-01 3.752650167259050651e-01 4.175771429986683270e-01 6.131376293448997927e-01 5.463797405837259591e-01 3.119918548921774004e-01 6.331762507678504459e-01 5.484632429281035559e-01 6.815448032785871302e-01 8.065695507425107991e-02 8.720129122297424207e-01 8.318188557125294480e-03 2.199323537180564170e-02 8.933872719887463454e-01 1.953120287872067706e-02 2.478721941404590234e-01 5.994061179859005994e-01 6.588362611693047155e-01 6.332808851020984564e-01 3.823849348043323326e-01 5.111091324899629251e-01 7.034808459110406531e-01 4.347681568463539481e-01 4.316973576672314961e-01 9.620411080123215664e-01 6.247837467655984467e-01 8.196961678222113301e-01 5.574601810887074294e-01 8.800635018469276094e-01 8.772255241161972528e-01 5.075275933138404527e-01 8.022583187266906224e-01 2.320670802521890286e-01 1.165626629103270195e-01 4.623759662685936744e-01 7.938327000737943617e-02 7.986374689793115378e-01 6.728842751465858862e-01 8.133909095059230765e-01 1.202639390769081329e-01 1.052937257108800262e-01 8.717600467040409473e-02 2.163819956545051104e-01 6.596483385763984852e-01 1.202843170392309258e-02 1.538789195854695091e-01 3.120247727263308901e-01 3.408168327248596308e-01 3.241861797851740556e-01 3.637074533655986208e-01 1.533669345890729119e-01 4.455921334699539660e-01 5.619140093874478437e-01 1.881731359879111887e-01 9.416670800570559052e-01 1.740018593664415247e-01 7.030242331869680505e-01 5.922055553954849172e-01 9.326211623391688077e-01 6.608322881013140027e-01 7.009721551241574478e-01 1.079126054675583202e-01 6.158176671761947940e-01
+5.185079639625639336e-01 9.613742991518259284e-01 5.555312825626229634e-01 2.647628827924735084e-01 6.003697207460141350e-01 5.392112376769145898e-01 6.781186965667050925e-01 9.908971748181496508e-01 4.124155872095397468e-01 9.814941401724619485e-02 2.684237785531295994e-02 1.774652505962848181e-01 1.707589529595294753e-01 4.640932098465534450e-01 2.882179883914587348e-01 7.276822905806898945e-01 6.145789546745269449e-01 1.100959863917608805e-01 6.798859723042820491e-01 9.096984032948918220e-01 3.971368455178179158e-01 2.959494950971321980e-01 3.742088799298171065e-02 1.960739526210202310e-01 7.536102695342027369e-01 6.680915510628401277e-01 4.136507204312135366e-01 3.613996339406737590e-01 3.605422038261204554e-01 7.098503555159476619e-01 8.093719147087541366e-01 6.344097009128880638e-01 3.990082448083617228e-01 2.805918009906902544e-01 7.078488167363675698e-01 9.969917259866583059e-01 9.442054998992396309e-01 1.329075240769165278e-01 6.810681350588387861e-02 8.503491437913293094e-01 8.347117439165431252e-01 2.381858201903953587e-01 7.884260706938626129e-01 7.109907917419661105e-01 6.390916681983604963e-02 6.174365227062991179e-01 5.085733343630816083e-01 1.716846139694149231e-01 9.065664924270055991e-02 5.625330757196970177e-01 3.539663480209681579e-01 8.937139525947165319e-01 3.981380511900556307e-02 7.403597927449541150e-01 3.803872284089604427e-02 6.729519695709765825e-01 5.306080908840085097e-01 2.091237680402112664e-01 5.902903662907804661e-01 2.094778612095482551e-01 7.323447855684165342e-01 3.644574495843493356e-01 2.006215478057034041e-01 3.737617545555030896e-01 5.253471759602216240e-01 4.287889547869583318e-01 7.086098806190446187e-01 4.510792335515292351e-01 6.383187180169215269e-01 8.779355722397681472e-01 4.221338898667141848e-01 6.375840144651815367e-01 8.683057298299173832e-01 6.093730356952498095e-01 9.297141161056151626e-01 7.770838342807246946e-01 6.549661287008456956e-02 2.835060738158660110e-01 4.474138867374952699e-01 8.530336387421445510e-01 3.160209657891883683e-01 8.301538680518486535e-01 6.646903097549101691e-01 7.187130118106234145e-01 1.651862041735395747e-01 9.578252676762609719e-01 6.490273812885494209e-02 9.777273484666341163e-01 8.930729829254262508e-01 9.851054752118463265e-01 4.094323402286751401e-01 1.139176240124337713e-01 7.612865863899589414e-01 2.266379302491570158e-01 6.998882496157835531e-01 9.945043379099228753e-01 7.111578056749194854e-01 7.806190603886183910e-01 3.410170920712443099e-01 9.446084168886822452e-01
+5.015172758330755931e-01 5.569527971282052237e-01 1.122406928736449094e-01 8.960352822124777461e-01 6.049568585854003810e-02 1.202196001338627918e-01 1.870314295763603196e-01 9.017590029396971296e-01 3.597904628087450485e-01 2.130941062746317671e-01 2.556281834629479111e-01 5.123669364829196438e-01 4.754061129282013409e-01 9.764470380372083369e-01 8.038663983900646848e-01 6.960491266420890666e-01 2.940135977911654264e-01 2.857282759910040326e-03 4.599343225832352999e-02 5.597554495210212977e-01 7.445266674304001908e-01 3.387528030535971180e-01 6.429542922125383031e-01 2.123331785532429627e-01 5.302332654117811739e-01 7.262555377662539557e-01 3.982425859900724507e-01 3.243388301740235402e-01 6.191064123738921898e-01 8.988047781373914580e-01 7.819700328765150088e-01 7.664269102804815992e-01 6.734095355422575757e-03 2.904762329148526945e-01 5.097537644843168625e-01 9.524734606001823423e-01 4.812869576591960463e-01 6.236868013640477493e-01 1.459170943214320726e-01 9.874505139403206844e-01 7.561708982837871407e-01 3.798591332432484924e-01 6.056633451375117438e-01 7.935708170258731764e-01 1.458141583518740569e-01 7.082511296391911237e-01 1.098798009731616343e-02 3.655618484905173160e-01 9.551862303858617009e-01 8.148959351152762487e-02 4.739306219219985294e-02 7.963357515359494876e-01 6.208332695202813944e-01 3.884182264923189409e-01 4.589167647950288531e-01 6.496652974138312775e-01 2.467528128074852889e-01 5.309593064844935206e-01 5.364606369543487574e-01 2.421352989851309756e-01 3.776834556696828660e-02 1.564861233558080267e-01 5.197231021782636740e-01 8.725375120634637494e-01 2.441225493455024820e-01 2.320363366041028330e-01 5.026358683423555185e-01 7.035766000474735771e-01 8.347805591467084563e-01 2.303229841813967393e-01 6.908373419683054850e-01 2.646662377366995056e-01 1.259467197942290007e-01 9.372770922994989595e-01 6.674216272867254940e-01 1.027944489143072238e-01 5.686267290346079806e-01 3.948222804451942958e-01 4.689706944496729868e-01 4.446117700449114807e-02 6.817992275557515081e-01 9.084821829413957106e-01 9.184021015315092518e-01 3.045815734169987632e-01 2.204958624923980537e-03 7.542672057172502553e-01 9.460844786545006269e-01 3.373139094575949848e-02 9.059565314915285494e-01 9.938525461318854504e-01 2.542072661725306437e-01 9.685734112479216229e-02 8.223629541824816203e-01 1.057429056898460118e-01 8.080679390260248063e-01 5.823014244609205914e-01 6.413551528031806725e-01 1.787341975438894170e-01 1.250471413912357388e-01 8.390281297596062782e-01

shared/package-files/d1/d12ee45a23c42919a2d224bc250dcae530a1cd2a59361026d668f25d081a513f/blob

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API ::std::tuple<at::Tensor,at::Tensor> _grid_sampler_2d_cpu_fallback_backward(const at::Tensor & grad_output, const at::Tensor & input, const at::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners);
+
+} // namespace compositeimplicitautograd
+} // namespace at

shared/package-files/d1/d1324a6081d2205c907151d97481d9d7d6fbb6ab2dfec63b899c232b372f6413/blob

@@ -0,0 +1,1615 @@
+"""
+Do NOT manually edit this file.
+Instead, run ./bin/ask_update.py.
+"""
+
+defined_facts = [
+    'algebraic',
+    'antihermitian',
+    'commutative',
+    'complex',
+    'composite',
+    'even',
+    'extended_negative',
+    'extended_nonnegative',
+    'extended_nonpositive',
+    'extended_nonzero',
+    'extended_positive',
+    'extended_real',
+    'finite',
+    'hermitian',
+    'imaginary',
+    'infinite',
+    'integer',
+    'irrational',
+    'negative',
+    'noninteger',
+    'nonnegative',
+    'nonpositive',
+    'nonzero',
+    'odd',
+    'positive',
+    'prime',
+    'rational',
+    'real',
+    'transcendental',
+    'zero',
+] # defined_facts
+
+
+full_implications = dict( [
+    # Implications of algebraic = True:
+    (('algebraic', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('finite', True),
+        ('infinite', False),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of algebraic = False:
+    (('algebraic', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of antihermitian = True:
+    (('antihermitian', True), set( (
+       ) ),
+     ),
+    # Implications of antihermitian = False:
+    (('antihermitian', False), set( (
+        ('imaginary', False),
+       ) ),
+     ),
+    # Implications of commutative = True:
+    (('commutative', True), set( (
+       ) ),
+     ),
+    # Implications of commutative = False:
+    (('commutative', False), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of complex = True:
+    (('complex', True), set( (
+        ('commutative', True),
+        ('finite', True),
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of complex = False:
+    (('complex', False), set( (
+        ('algebraic', False),
+        ('composite', False),
+        ('even', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of composite = True:
+    (('composite', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('positive', True),
+        ('prime', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of composite = False:
+    (('composite', False), set( (
+       ) ),
+     ),
+    # Implications of even = True:
+    (('even', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('noninteger', False),
+        ('odd', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of even = False:
+    (('even', False), set( (
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_negative = True:
+    (('extended_negative', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('nonnegative', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_negative = False:
+    (('extended_negative', False), set( (
+        ('negative', False),
+       ) ),
+     ),
+    # Implications of extended_nonnegative = True:
+    (('extended_nonnegative', True), set( (
+        ('commutative', True),
+        ('extended_negative', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('negative', False),
+       ) ),
+     ),
+    # Implications of extended_nonnegative = False:
+    (('extended_nonnegative', False), set( (
+        ('composite', False),
+        ('extended_positive', False),
+        ('nonnegative', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonpositive = True:
+    (('extended_nonpositive', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_nonpositive = False:
+    (('extended_nonpositive', False), set( (
+        ('extended_negative', False),
+        ('negative', False),
+        ('nonpositive', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonzero = True:
+    (('extended_nonzero', True), set( (
+        ('commutative', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonzero = False:
+    (('extended_nonzero', False), set( (
+        ('composite', False),
+        ('extended_negative', False),
+        ('extended_positive', False),
+        ('negative', False),
+        ('nonzero', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_positive = True:
+    (('extended_positive', True), set( (
+        ('commutative', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('negative', False),
+        ('nonpositive', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_positive = False:
+    (('extended_positive', False), set( (
+        ('composite', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_real = True:
+    (('extended_real', True), set( (
+        ('commutative', True),
+        ('imaginary', False),
+       ) ),
+     ),
+    # Implications of extended_real = False:
+    (('extended_real', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of finite = True:
+    (('finite', True), set( (
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of finite = False:
+    (('finite', False), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('imaginary', False),
+        ('infinite', True),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of hermitian = True:
+    (('hermitian', True), set( (
+       ) ),
+     ),
+    # Implications of hermitian = False:
+    (('hermitian', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of imaginary = True:
+    (('imaginary', True), set( (
+        ('antihermitian', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', False),
+        ('finite', True),
+        ('infinite', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of imaginary = False:
+    (('imaginary', False), set( (
+       ) ),
+     ),
+    # Implications of infinite = True:
+    (('infinite', True), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('finite', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of infinite = False:
+    (('infinite', False), set( (
+        ('finite', True),
+       ) ),
+     ),
+    # Implications of integer = True:
+    (('integer', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('irrational', False),
+        ('noninteger', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of integer = False:
+    (('integer', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of irrational = True:
+    (('irrational', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', False),
+        ('noninteger', True),
+        ('nonzero', True),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of irrational = False:
+    (('irrational', False), set( (
+       ) ),
+     ),
+    # Implications of negative = True:
+    (('negative', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_negative', True),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('nonnegative', False),
+        ('nonpositive', True),
+        ('nonzero', True),
+        ('positive', False),
+        ('prime', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of negative = False:
+    (('negative', False), set( (
+       ) ),
+     ),
+    # Implications of noninteger = True:
+    (('noninteger', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of noninteger = False:
+    (('noninteger', False), set( (
+       ) ),
+     ),
+    # Implications of nonnegative = True:
+    (('nonnegative', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('negative', False),
+        ('real', True),
+       ) ),
+     ),
+    # Implications of nonnegative = False:
+    (('nonnegative', False), set( (
+        ('composite', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonpositive = True:
+    (('nonpositive', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_nonpositive', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('positive', False),
+        ('prime', False),
+        ('real', True),
+       ) ),
+     ),
+    # Implications of nonpositive = False:
+    (('nonpositive', False), set( (
+        ('negative', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonzero = True:
+    (('nonzero', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonzero = False:
+    (('nonzero', False), set( (
+        ('composite', False),
+        ('negative', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of odd = True:
+    (('odd', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('noninteger', False),
+        ('nonzero', True),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of odd = False:
+    (('odd', False), set( (
+       ) ),
+     ),
+    # Implications of positive = True:
+    (('positive', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('negative', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of positive = False:
+    (('positive', False), set( (
+        ('composite', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of prime = True:
+    (('prime', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('positive', True),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of prime = False:
+    (('prime', False), set( (
+       ) ),
+     ),
+    # Implications of rational = True:
+    (('rational', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('irrational', False),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of rational = False:
+    (('rational', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of real = True:
+    (('real', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of real = False:
+    (('real', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of transcendental = True:
+    (('transcendental', True), set( (
+        ('algebraic', False),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('finite', True),
+        ('infinite', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of transcendental = False:
+    (('transcendental', False), set( (
+       ) ),
+     ),
+    # Implications of zero = True:
+    (('zero', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', True),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of zero = False:
+    (('zero', False), set( (
+       ) ),
+     ),
+ ] ) # full_implications
+
+
+prereq = {
+
+    # facts that could determine the value of algebraic
+    'algebraic': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of antihermitian
+    'antihermitian': {
+        'imaginary',
+    },
+
+    # facts that could determine the value of commutative
+    'commutative': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of complex
+    'complex': {
+        'algebraic',
+        'commutative',
+        'composite',
+        'even',
+        'finite',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of composite
+    'composite': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of even
+    'even': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'noninteger',
+        'odd',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_negative
+    'extended_negative': {
+        'commutative',
+        'composite',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonnegative',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonnegative
+    'extended_nonnegative': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonnegative',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonpositive
+    'extended_nonpositive': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonpositive',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonzero
+    'extended_nonzero': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_positive
+    'extended_positive': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonpositive',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_real
+    'extended_real': {
+        'commutative',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of finite
+    'finite': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of hermitian
+    'hermitian': {
+        'composite',
+        'even',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of imaginary
+    'imaginary': {
+        'antihermitian',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of infinite
+    'infinite': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of integer
+    'integer': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'irrational',
+        'noninteger',
+        'odd',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of irrational
+    'irrational': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of negative
+    'negative': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of noninteger
+    'noninteger': {
+        'commutative',
+        'composite',
+        'even',
+        'extended_real',
+        'imaginary',
+        'integer',
+        'irrational',
+        'odd',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of nonnegative
+    'nonnegative': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of nonpositive
+    'nonpositive': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_nonpositive',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of nonzero
+    'nonzero': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_nonzero',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'irrational',
+        'negative',
+        'odd',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of odd
+    'odd': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'noninteger',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of positive
+    'positive': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of prime
+    'prime': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of rational
+    'rational': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'odd',
+        'prime',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of real
+    'real': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'zero',
+    },
+
+    # facts that could determine the value of transcendental
+    'transcendental': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'zero',
+    },
+
+    # facts that could determine the value of zero
+    'zero': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+    },
+
+} # prereq
+
+
+# Note: the order of the beta rules is used in the beta_triggers
+beta_rules = [
+
+    # Rules implying composite = True
+    ({('even', True), ('positive', True), ('prime', False)},
+        ('composite', True)),
+
+    # Rules implying even = False
+    ({('composite', False), ('positive', True), ('prime', False)},
+        ('even', False)),
+
+    # Rules implying even = True
+    ({('integer', True), ('odd', False)},
+        ('even', True)),
+
+    # Rules implying extended_negative = True
+    ({('extended_positive', False), ('extended_real', True), ('zero', False)},
+        ('extended_negative', True)),
+    ({('extended_nonpositive', True), ('extended_nonzero', True)},
+        ('extended_negative', True)),
+
+    # Rules implying extended_nonnegative = True
+    ({('extended_negative', False), ('extended_real', True)},
+        ('extended_nonnegative', True)),
+
+    # Rules implying extended_nonpositive = True
+    ({('extended_positive', False), ('extended_real', True)},
+        ('extended_nonpositive', True)),
+
+    # Rules implying extended_nonzero = True
+    ({('extended_real', True), ('zero', False)},
+        ('extended_nonzero', True)),
+
+    # Rules implying extended_positive = True
+    ({('extended_negative', False), ('extended_real', True), ('zero', False)},
+        ('extended_positive', True)),
+    ({('extended_nonnegative', True), ('extended_nonzero', True)},
+        ('extended_positive', True)),
+
+    # Rules implying extended_real = False
+    ({('infinite', False), ('real', False)},
+        ('extended_real', False)),
+    ({('extended_negative', False), ('extended_positive', False), ('zero', False)},
+        ('extended_real', False)),
+
+    # Rules implying infinite = True
+    ({('extended_real', True), ('real', False)},
+        ('infinite', True)),
+
+    # Rules implying irrational = True
+    ({('rational', False), ('real', True)},
+        ('irrational', True)),
+
+    # Rules implying negative = True
+    ({('positive', False), ('real', True), ('zero', False)},
+        ('negative', True)),
+    ({('nonpositive', True), ('nonzero', True)},
+        ('negative', True)),
+    ({('extended_negative', True), ('finite', True)},
+        ('negative', True)),
+
+    # Rules implying noninteger = True
+    ({('extended_real', True), ('integer', False)},
+        ('noninteger', True)),
+
+    # Rules implying nonnegative = True
+    ({('negative', False), ('real', True)},
+        ('nonnegative', True)),
+    ({('extended_nonnegative', True), ('finite', True)},
+        ('nonnegative', True)),
+
+    # Rules implying nonpositive = True
+    ({('positive', False), ('real', True)},
+        ('nonpositive', True)),
+    ({('extended_nonpositive', True), ('finite', True)},
+        ('nonpositive', True)),
+
+    # Rules implying nonzero = True
+    ({('extended_nonzero', True), ('finite', True)},
+        ('nonzero', True)),
+
+    # Rules implying odd = True
+    ({('even', False), ('integer', True)},
+        ('odd', True)),
+
+    # Rules implying positive = False
+    ({('composite', False), ('even', True), ('prime', False)},
+        ('positive', False)),
+
+    # Rules implying positive = True
+    ({('negative', False), ('real', True), ('zero', False)},
+        ('positive', True)),
+    ({('nonnegative', True), ('nonzero', True)},
+        ('positive', True)),
+    ({('extended_positive', True), ('finite', True)},
+        ('positive', True)),
+
+    # Rules implying prime = True
+    ({('composite', False), ('even', True), ('positive', True)},
+        ('prime', True)),
+
+    # Rules implying real = False
+    ({('negative', False), ('positive', False), ('zero', False)},
+        ('real', False)),
+
+    # Rules implying real = True
+    ({('extended_real', True), ('infinite', False)},
+        ('real', True)),
+    ({('extended_real', True), ('finite', True)},
+        ('real', True)),
+
+    # Rules implying transcendental = True
+    ({('algebraic', False), ('complex', True)},
+        ('transcendental', True)),
+
+    # Rules implying zero = True
+    ({('extended_negative', False), ('extended_positive', False), ('extended_real', True)},
+        ('zero', True)),
+    ({('negative', False), ('positive', False), ('real', True)},
+        ('zero', True)),
+    ({('extended_nonnegative', True), ('extended_nonpositive', True)},
+        ('zero', True)),
+    ({('nonnegative', True), ('nonpositive', True)},
+        ('zero', True)),
+
+] # beta_rules
+beta_triggers = {
+    ('algebraic', False): [32, 11, 3, 8, 29, 14, 25, 13, 17, 7],
+    ('algebraic', True): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('antihermitian', False): [],
+    ('commutative', False): [],
+    ('complex', False): [10, 12, 11, 3, 8, 17, 7],
+    ('complex', True): [32, 10, 30, 31, 27, 16, 21, 19, 22],
+    ('composite', False): [1, 28, 24],
+    ('composite', True): [23, 2],
+    ('even', False): [23, 11, 3, 8, 29, 14, 25, 7],
+    ('even', True): [3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 0, 28, 24, 7],
+    ('extended_negative', False): [11, 33, 8, 5, 29, 34, 25, 18],
+    ('extended_negative', True): [30, 12, 31, 29, 14, 20, 16, 21, 22, 17],
+    ('extended_nonnegative', False): [11, 3, 6, 29, 14, 20, 7],
+    ('extended_nonnegative', True): [30, 12, 31, 33, 8, 9, 6, 29, 34, 25, 18, 19, 35, 17, 7],
+    ('extended_nonpositive', False): [11, 8, 5, 29, 25, 18, 7],
+    ('extended_nonpositive', True): [30, 12, 31, 3, 33, 4, 5, 29, 14, 34, 20, 21, 35, 17, 7],
+    ('extended_nonzero', False): [11, 33, 6, 5, 29, 34, 20, 18],
+    ('extended_nonzero', True): [30, 12, 31, 3, 8, 4, 9, 6, 5, 29, 14, 25, 22, 17],
+    ('extended_positive', False): [11, 3, 33, 6, 29, 14, 34, 20],
+    ('extended_positive', True): [30, 12, 31, 29, 25, 18, 27, 19, 22, 17],
+    ('extended_real', False): [],
+    ('extended_real', True): [30, 12, 31, 3, 33, 8, 6, 5, 17, 7],
+    ('finite', False): [11, 3, 8, 17, 7],
+    ('finite', True): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('hermitian', False): [10, 12, 11, 3, 8, 17, 7],
+    ('imaginary', True): [32],
+    ('infinite', False): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('infinite', True): [11, 3, 8, 17, 7],
+    ('integer', False): [11, 3, 8, 29, 14, 25, 17, 7],
+    ('integer', True): [23, 2, 3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 7],
+    ('irrational', True): [32, 3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19],
+    ('negative', False): [29, 34, 25, 18],
+    ('negative', True): [32, 13, 17],
+    ('noninteger', True): [30, 12, 31, 3, 8, 4, 9, 6, 5, 29, 14, 25, 22],
+    ('nonnegative', False): [11, 3, 8, 29, 14, 20, 7],
+    ('nonnegative', True): [32, 33, 8, 9, 6, 34, 25, 26, 20, 27, 21, 22, 35, 36, 13, 17, 7],
+    ('nonpositive', False): [11, 3, 8, 29, 25, 18, 7],
+    ('nonpositive', True): [32, 3, 33, 4, 5, 14, 34, 15, 18, 16, 19, 22, 35, 36, 13, 17, 7],
+    ('nonzero', False): [29, 34, 20, 18],
+    ('nonzero', True): [32, 3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19, 13, 17],
+    ('odd', False): [2],
+    ('odd', True): [3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19],
+    ('positive', False): [29, 14, 34, 20],
+    ('positive', True): [32, 0, 1, 28, 13, 17],
+    ('prime', False): [0, 1, 24],
+    ('prime', True): [23, 2],
+    ('rational', False): [11, 3, 8, 29, 14, 25, 13, 17, 7],
+    ('rational', True): [3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 17, 7],
+    ('real', False): [10, 12, 11, 3, 8, 17, 7],
+    ('real', True): [32, 3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 13, 17, 7],
+    ('transcendental', True): [10, 30, 31, 11, 3, 8, 29, 14, 25, 27, 16, 21, 19, 22, 13, 17, 7],
+    ('zero', False): [11, 3, 8, 29, 14, 25, 7],
+    ('zero', True): [],
+} # beta_triggers
+
+
+generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,
+               'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers}

shared/package-files/d1/d1329d662c712d603ec70b40670e07729a899a3e17a6bc7566472dcb48134596/blob

@@ -0,0 +1,120 @@
+import functools
+import os
+import pathlib
+import types
+import warnings
+
+from typing import Union, Iterable, ContextManager, BinaryIO, TextIO, Any
+
+from . import _common
+
+Package = Union[types.ModuleType, str]
+Resource = str
+
+
+def deprecated(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        warnings.warn(
+            f"{func.__name__} is deprecated. Use files() instead. "
+            "Refer to https://importlib-resources.readthedocs.io"
+            "/en/latest/using.html#migrating-from-legacy for migration advice.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def normalize_path(path: Any) -> str:
+    """Normalize a path by ensuring it is a string.
+
+    If the resulting string contains path separators, an exception is raised.
+    """
+    str_path = str(path)
+    parent, file_name = os.path.split(str_path)
+    if parent:
+        raise ValueError(f'{path!r} must be only a file name')
+    return file_name
+
+
+@deprecated
+def open_binary(package: Package, resource: Resource) -> BinaryIO:
+    """Return a file-like object opened for binary reading of the resource."""
+    return (_common.files(package) / normalize_path(resource)).open('rb')
+
+
+@deprecated
+def read_binary(package: Package, resource: Resource) -> bytes:
+    """Return the binary contents of the resource."""
+    return (_common.files(package) / normalize_path(resource)).read_bytes()
+
+
+@deprecated
+def open_text(
+    package: Package,
+    resource: Resource,
+    encoding: str = 'utf-8',
+    errors: str = 'strict',
+) -> TextIO:
+    """Return a file-like object opened for text reading of the resource."""
+    return (_common.files(package) / normalize_path(resource)).open(
+        'r', encoding=encoding, errors=errors
+    )
+
+
+@deprecated
+def read_text(
+    package: Package,
+    resource: Resource,
+    encoding: str = 'utf-8',
+    errors: str = 'strict',
+) -> str:
+    """Return the decoded string of the resource.
+
+    The decoding-related arguments have the same semantics as those of
+    bytes.decode().
+    """
+    with open_text(package, resource, encoding, errors) as fp:
+        return fp.read()
+
+
+@deprecated
+def contents(package: Package) -> Iterable[str]:
+    """Return an iterable of entries in `package`.
+
+    Note that not all entries are resources.  Specifically, directories are
+    not considered resources.  Use `is_resource()` on each entry returned here
+    to check if it is a resource or not.
+    """
+    return [path.name for path in _common.files(package).iterdir()]
+
+
+@deprecated
+def is_resource(package: Package, name: str) -> bool:
+    """True if `name` is a resource inside `package`.
+
+    Directories are *not* resources.
+    """
+    resource = normalize_path(name)
+    return any(
+        traversable.name == resource and traversable.is_file()
+        for traversable in _common.files(package).iterdir()
+    )
+
+
+@deprecated
+def path(
+    package: Package,
+    resource: Resource,
+) -> ContextManager[pathlib.Path]:
+    """A context manager providing a file path object to the resource.
+
+    If the resource does not already exist on its own on the file system,
+    a temporary file will be created. If the file was created, the file
+    will be deleted upon exiting the context manager (no exception is
+    raised if the file was deleted prior to the context manager
+    exiting).
+    """
+    return _common.as_file(_common.files(package) / normalize_path(resource))

shared/package-files/d1/d132f83197095d4a28f6a03bbaed2f2efede1eb5d17ab566c9f8bb3b5e3d213c/blob

@@ -0,0 +1,9 @@
+"""CUDA Driver
+
+- Driver API binding
+- NVVM API binding
+- Device array implementation
+
+"""
+from numba.core import config
+assert not config.ENABLE_CUDASIM, 'Cannot use real driver API with simulator'

shared/package-files/d1/d13744c2cd7cd7bf54732637d88ce57fc6b8cd561beadeb62c4190df13ff3dd9/blob

@@ -0,0 +1,148 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+
+#include <torch/csrc/jit/ir/ir.h>
+#include <torch/csrc/jit/python/update_graph_executor_opt.h>
+#include <torch/csrc/jit/runtime/argument_spec.h>
+#include <torch/csrc/jit/runtime/interpreter.h>
+#include <torch/csrc/jit/runtime/variable_tensor_list.h>
+
+C10_DECLARE_bool(torch_jit_enable_new_executor);
+
+C10_DECLARE_bool(torch_jit_execution_plan_reuse_code_graph);
+
+namespace torch::jit {
+struct GraphExecutorState;
+struct Code;
+
+enum ExecutorExecutionMode {
+  SIMPLE,
+  PROFILING,
+};
+
+struct ExecutionPlan {
+  ExecutionPlan() = default;
+  ExecutionPlan(std::shared_ptr<Graph> graph, std::string function_name)
+      : code(graph, std::move(function_name)),
+        graph(
+            FLAGS_torch_jit_execution_plan_reuse_code_graph
+                ? code.graph()
+                : std::move(graph)) {}
+
+  operator bool() const {
+    return static_cast<bool>(graph);
+  }
+
+  Code code;
+  std::shared_ptr<Graph> graph;
+};
+
+// Notice that those structs don't manage lifetime of their members.
+// They are only valid only right after you call getDebugState() and should
+// never be used again once another GraphExecutor function is called.
+
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+struct GraphExecutorState {
+  const Graph* graph = nullptr;
+  ExecutionPlan fallback; // XXX: members of this field are optional
+  std::unordered_map<ArgumentSpec, ExecutionPlan> execution_plans;
+};
+
+struct TORCH_API EnableProfilingGuard {
+  EnableProfilingGuard();
+  ~EnableProfilingGuard();
+
+ private:
+  bool old_executor_mode = false;
+  bool old_get_optimize = false;
+};
+
+struct GraphExecutorImplBase;
+struct TORCH_API GraphExecutor {
+  GraphExecutor() = default;
+  GraphExecutor(const std::shared_ptr<Graph>& graph, std::string function_name);
+
+  GraphExecutor(
+      const std::shared_ptr<Graph>& graph,
+      std::string function_name,
+      ExecutorExecutionMode executor_mode);
+
+  void run(Stack& inputs);
+  c10::intrusive_ptr<Future> runAsync(
+      Stack& stack,
+      TaskLauncher taskLauncher = at::launch);
+
+  // `remaining_bailout_depth` stands for the maximum number of profiled and
+  // specialized recompilations allowed for the current `GraphExecutor`. if
+  // remaining_bailout_depth is equal to 0, `GraphExecutor` won't perform any
+  // profiling and specialization. This is also equivalent to the
+  // SIMPLE_EXECUTOR mode. if remaining_bailout_depth is greater than 0,
+  // `GraphExecutor` will profile and specialize its input graph based on the
+  // profiled information whenever a bailout check is failed/triggered, a new
+  // `GraphExecutor` will be created. This new `GraphExecutor`'s
+  // remaining_bailout_depth will be reduced by 1.
+  // If no bailout depth is passed, the depth will be initialized from the
+  // current global fusion strategy settings.
+  const ExecutionPlan& getPlanFor(
+      Stack& inputs,
+      c10::optional<size_t> remaining_bailout_depth = c10::nullopt);
+  GraphExecutorState getDebugState();
+
+  void debugFlushCompilationCache();
+
+  bool isOptimized() const;
+
+ private:
+  std::shared_ptr<GraphExecutorImplBase> pImpl;
+};
+
+TORCH_API Node* replaceBlockWithFallbackGraph(
+    Block* b,
+    ArrayRef<Value*> inputs);
+
+// These passes need to run before it is valid to pass to the interpreter
+// regardless of whether sizes have been specialized or not.
+TORCH_API void runRequiredPasses(const std::shared_ptr<Graph>& g);
+
+TORCH_API void debugSetFusionGroupInlining(bool state);
+TORCH_API bool getFusionGroupInlining();
+
+TORCH_API void debugSetAutodiffSubgraphInlining(bool state);
+TORCH_API std::shared_ptr<Graph> lastExecutedOptimizedGraph();
+
+TORCH_API std::atomic<bool>& getProfilingMode();
+TORCH_API std::atomic<bool>& getExecutorMode();
+TORCH_API std::atomic<size_t>& getNumProfiledRuns();
+TORCH_API size_t getBailoutDepth();
+TORCH_API bool IsNewExecutorEnabled();
+
+struct TORCH_API GraphOptimizerEnabledGuard {
+  GraphOptimizerEnabledGuard(bool state)
+      : old_state_(getGraphExecutorOptimize()) {
+    setGraphExecutorOptimize(state);
+  }
+
+  ~GraphOptimizerEnabledGuard() {
+    setGraphExecutorOptimize(old_state_);
+  }
+
+  bool old_state_;
+};
+
+namespace detail {
+
+GraphExecutor* getGradExecutor(Operation& op);
+
+GraphExecutor* getDifferentiableGraphOpExecutor(Operation& op);
+
+// for debugging information we expose a way to get the last actually
+// run graph. Previous approaches allowed querying the GraphExecutor
+// for what graph it would run in certain circumstances (graphFor), but
+// this is fragile because we sometimes change how these decisions are made.
+// This interface still allows our tests to look at optimized graphs, but
+// with less plumbing.
+} // namespace detail
+
+} // namespace torch::jit

shared/package-files/d1/d139a725e64239a4d69de79603ae839712a06946494df3f48ca80b018d638b28/blob

@@ -0,0 +1,23 @@
+import pytest
+
+import pandas as pd
+
+
+class TestResolution:
+    @pytest.mark.parametrize(
+        "freq,expected",
+        [
+            ("Y", "year"),
+            ("Q", "quarter"),
+            ("M", "month"),
+            ("D", "day"),
+            ("h", "hour"),
+            ("min", "minute"),
+            ("s", "second"),
+            ("ms", "millisecond"),
+            ("us", "microsecond"),
+        ],
+    )
+    def test_resolution(self, freq, expected):
+        idx = pd.period_range(start="2013-04-01", periods=30, freq=freq)
+        assert idx.resolution == expected

shared/package-files/d1/d139acf8eb2a687729587edad85e26a8aa8457e1b96ed8992ad7b77149c45903/blob

@@ -0,0 +1,10 @@
+"""
+Timeseries API
+"""
+
+from pandas._libs.tslibs.parsing import guess_datetime_format
+
+from pandas.tseries import offsets
+from pandas.tseries.frequencies import infer_freq
+
+__all__ = ["infer_freq", "offsets", "guess_datetime_format"]

shared/package-files/d1/d13ad093943853e1af4974dee049a287a07624983658cbbfbb4a528fddb0a950/blob

@@ -0,0 +1,174 @@
+"""Singleton mechanism"""
+
+
+from .core import Registry
+from .sympify import sympify
+
+
+class SingletonRegistry(Registry):
+    """
+    The registry for the singleton classes (accessible as ``S``).
+
+    Explanation
+    ===========
+
+    This class serves as two separate things.
+
+    The first thing it is is the ``SingletonRegistry``. Several classes in
+    SymPy appear so often that they are singletonized, that is, using some
+    metaprogramming they are made so that they can only be instantiated once
+    (see the :class:`sympy.core.singleton.Singleton` class for details). For
+    instance, every time you create ``Integer(0)``, this will return the same
+    instance, :class:`sympy.core.numbers.Zero`. All singleton instances are
+    attributes of the ``S`` object, so ``Integer(0)`` can also be accessed as
+    ``S.Zero``.
+
+    Singletonization offers two advantages: it saves memory, and it allows
+    fast comparison. It saves memory because no matter how many times the
+    singletonized objects appear in expressions in memory, they all point to
+    the same single instance in memory. The fast comparison comes from the
+    fact that you can use ``is`` to compare exact instances in Python
+    (usually, you need to use ``==`` to compare things). ``is`` compares
+    objects by memory address, and is very fast.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Integer
+    >>> a = Integer(0)
+    >>> a is S.Zero
+    True
+
+    For the most part, the fact that certain objects are singletonized is an
+    implementation detail that users should not need to worry about. In SymPy
+    library code, ``is`` comparison is often used for performance purposes
+    The primary advantage of ``S`` for end users is the convenient access to
+    certain instances that are otherwise difficult to type, like ``S.Half``
+    (instead of ``Rational(1, 2)``).
+
+    When using ``is`` comparison, make sure the argument is sympified. For
+    instance,
+
+    >>> x = 0
+    >>> x is S.Zero
+    False
+
+    This problem is not an issue when using ``==``, which is recommended for
+    most use-cases:
+
+    >>> 0 == S.Zero
+    True
+
+    The second thing ``S`` is is a shortcut for
+    :func:`sympy.core.sympify.sympify`. :func:`sympy.core.sympify.sympify` is
+    the function that converts Python objects such as ``int(1)`` into SymPy
+    objects such as ``Integer(1)``. It also converts the string form of an
+    expression into a SymPy expression, like ``sympify("x**2")`` ->
+    ``Symbol("x")**2``. ``S(1)`` is the same thing as ``sympify(1)``
+    (basically, ``S.__call__`` has been defined to call ``sympify``).
+
+    This is for convenience, since ``S`` is a single letter. It's mostly
+    useful for defining rational numbers. Consider an expression like ``x +
+    1/2``. If you enter this directly in Python, it will evaluate the ``1/2``
+    and give ``0.5``, because both arguments are ints (see also
+    :ref:`tutorial-gotchas-final-notes`). However, in SymPy, you usually want
+    the quotient of two integers to give an exact rational number. The way
+    Python's evaluation works, at least one side of an operator needs to be a
+    SymPy object for the SymPy evaluation to take over. You could write this
+    as ``x + Rational(1, 2)``, but this is a lot more typing. A shorter
+    version is ``x + S(1)/2``. Since ``S(1)`` returns ``Integer(1)``, the
+    division will return a ``Rational`` type, since it will call
+    ``Integer.__truediv__``, which knows how to return a ``Rational``.
+
+    """
+    __slots__ = ()
+
+    # Also allow things like S(5)
+    __call__ = staticmethod(sympify)
+
+    def __init__(self):
+        self._classes_to_install = {}
+        # Dict of classes that have been registered, but that have not have been
+        # installed as an attribute of this SingletonRegistry.
+        # Installation automatically happens at the first attempt to access the
+        # attribute.
+        # The purpose of this is to allow registration during class
+        # initialization during import, but not trigger object creation until
+        # actual use (which should not happen until after all imports are
+        # finished).
+
+    def register(self, cls):
+        # Make sure a duplicate class overwrites the old one
+        if hasattr(self, cls.__name__):
+            delattr(self, cls.__name__)
+        self._classes_to_install[cls.__name__] = cls
+
+    def __getattr__(self, name):
+        """Python calls __getattr__ if no attribute of that name was installed
+        yet.
+
+        Explanation
+        ===========
+
+        This __getattr__ checks whether a class with the requested name was
+        already registered but not installed; if no, raises an AttributeError.
+        Otherwise, retrieves the class, calculates its singleton value, installs
+        it as an attribute of the given name, and unregisters the class."""
+        if name not in self._classes_to_install:
+            raise AttributeError(
+                "Attribute '%s' was not installed on SymPy registry %s" % (
+                name, self))
+        class_to_install = self._classes_to_install[name]
+        value_to_install = class_to_install()
+        self.__setattr__(name, value_to_install)
+        del self._classes_to_install[name]
+        return value_to_install
+
+    def __repr__(self):
+        return "S"
+
+S = SingletonRegistry()
+
+
+class Singleton(type):
+    """
+    Metaclass for singleton classes.
+
+    Explanation
+    ===========
+
+    A singleton class has only one instance which is returned every time the
+    class is instantiated. Additionally, this instance can be accessed through
+    the global registry object ``S`` as ``S.<class_name>``.
+
+    Examples
+    ========
+
+        >>> from sympy import S, Basic
+        >>> from sympy.core.singleton import Singleton
+        >>> class MySingleton(Basic, metaclass=Singleton):
+        ...     pass
+        >>> Basic() is Basic()
+        False
+        >>> MySingleton() is MySingleton()
+        True
+        >>> S.MySingleton is MySingleton()
+        True
+
+    Notes
+    =====
+
+    Instance creation is delayed until the first time the value is accessed.
+    (SymPy versions before 1.0 would create the instance during class
+    creation time, which would be prone to import cycles.)
+    """
+    def __init__(cls, *args, **kwargs):
+        cls._instance = obj = Basic.__new__(cls)
+        cls.__new__ = lambda cls: obj
+        cls.__getnewargs__ = lambda obj: ()
+        cls.__getstate__ = lambda obj: None
+        S.register(cls)
+
+
+# Delayed to avoid cyclic import
+from .basic import Basic

shared/package-files/d1/d13da4530fb2a70d9d66ee96508e6aa0de35f1c0e60a32e52b71b847cec9d292/blob

@@ -0,0 +1,250 @@
+import torch
+from torch.fx import GraphModule
+from torch.fx import Node
+
+from .pt2e.prepare import prepare
+from .pt2e.qat_utils import (
+    _fuse_conv_bn_qat,
+    _fold_conv_bn_qat,
+)
+from .pt2e.utils import (
+    _get_node_name_to_scope,
+    _fuse_conv_bn_,
+    _disallow_eval_train,
+)
+from .pt2e.representation import reference_representation_rewrite
+from .quantize_fx import _convert_to_reference_decomposed_fx
+from torch.ao.quantization.quantizer import (  # noqa: F401
+    Quantizer,
+    QuantizationSpecBase,
+    QuantizationSpec,
+    FixedQParamsQuantizationSpec,
+    SharedQuantizationSpec,
+    DerivedQuantizationSpec,
+    QuantizationAnnotation,
+)
+from torch.fx.passes.infra.pass_manager import PassManager
+from torch.ao.quantization.pt2e.duplicate_dq_pass import DuplicateDQPass
+from torch.ao.quantization.pt2e.port_metadata_pass import PortNodeMetaForQDQ
+from torch._inductor.constant_folding import constant_fold
+
+__all__ = [
+    "prepare_pt2e",
+    "prepare_qat_pt2e",
+    "convert_pt2e",
+]
+
+
+def prepare_pt2e(
+    model: GraphModule,
+    quantizer: Quantizer,
+) -> GraphModule:
+    """Prepare a model for post training quantization
+
+    Args:
+      * `model` (torch.fx.GraphModule): a model captured by `torch.export` API
+        in the short term we are using `torch._export.capture_pre_autograd_graph`,
+        in the long term we'll migrate to some `torch.export` API
+      * `quantizer`: A backend specific quantizer that conveys how user want the
+        model to be quantized. Tutorial for how to write a quantizer can be found here:
+        https://pytorch.org/tutorials/prototype/pt2e_quantizer.html
+
+    Return:
+      A GraphModule with observer (based on quantizer annotation), ready for calibration
+
+    Example::
+
+        import torch
+        from torch.ao.quantization.quantize_pt2e import prepare_pt2e
+        from torch._export import capture_pre_autograd_graph
+        from torch.ao.quantization.quantizer import (
+            XNNPACKQuantizer,
+            get_symmetric_quantization_config,
+        )
+
+        class M(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = torch.nn.Linear(5, 10)
+
+           def forward(self, x):
+               return self.linear(x)
+
+        # initialize a floating point model
+        float_model = M().eval()
+
+        # define calibration function
+        def calibrate(model, data_loader):
+            model.eval()
+            with torch.no_grad():
+                for image, target in data_loader:
+                    model(image)
+
+        # Step 1. program capture
+        # NOTE: this API will be updated to torch.export API in the future, but the captured
+        # result shoud mostly stay the same
+        m = capture_pre_autograd_graph(m, *example_inputs)
+        # we get a model with aten ops
+
+        # Step 2. quantization
+        # backend developer will write their own Quantizer and expose methods to allow
+        # users to express how they
+        # want the model to be quantized
+        quantizer = XNNPACKQuantizer().set_global(get_symmetric_quantization_config())
+        m = prepare_pt2e(m, quantizer)
+
+        # run calibration
+        # calibrate(m, sample_inference_data)
+    """
+    torch._C._log_api_usage_once("quantization_api.quantize_pt2e.prepare_pt2e")
+    original_graph_meta = model.meta
+    node_name_to_scope = _get_node_name_to_scope(model)
+    # TODO: check qconfig_mapping to make sure conv and bn are both configured
+    # to be quantized before fusion
+    # TODO: (maybe) rewrite this with subgraph_rewriter
+    _fuse_conv_bn_(model)
+    quantizer.transform_for_annotation(model)
+    quantizer.annotate(model)
+    quantizer.validate(model)
+    model = prepare(model, node_name_to_scope, is_qat=False)
+    model.meta.update(original_graph_meta)
+    model = _disallow_eval_train(model)
+    return model
+
+def prepare_qat_pt2e(
+    model: GraphModule,
+    quantizer: Quantizer,
+) -> GraphModule:
+    """Prepare a model for quantization aware training
+
+    Args:
+      * `model` (torch.fx.GraphModule): see :func:`~torch.ao.quantization.quantize_pt2e.prepare_pt2e`
+      * `quantizer`: see :func:`~torch.ao.quantization.quantize_pt2e.prepare_pt2e`
+
+    Return:
+      A GraphModule with fake quant modules (based on quantizer annotation), ready for
+      quantization aware training
+
+    Example::
+        import torch
+        from torch.ao.quantization.quantize_pt2e import prepare_qat_pt2e
+        from torch._export import capture_pre_autograd_graph
+        from torch.ao.quantization.quantizer import (
+            XNNPACKQuantizer,
+            get_symmetric_quantization_config,
+        )
+
+        class M(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = torch.nn.Linear(5, 10)
+
+           def forward(self, x):
+               return self.linear(x)
+
+        # initialize a floating point model
+        float_model = M().eval()
+
+        # define the training loop for quantization aware training
+        def train_loop(model, train_data):
+            model.train()
+            for image, target in data_loader:
+                ...
+
+        # Step 1. program capture
+        # NOTE: this API will be updated to torch.export API in the future, but the captured
+        # result shoud mostly stay the same
+        m = capture_pre_autograd_graph(m, *example_inputs)
+        # we get a model with aten ops
+
+        # Step 2. quantization
+        # backend developer will write their own Quantizer and expose methods to allow
+        # users to express how they
+        # want the model to be quantized
+        quantizer = XNNPACKQuantizer().set_global(get_symmetric_quantization_config())
+        m = prepare_qat_pt2e(m, quantizer)
+
+        # run quantization aware training
+        train_loop(prepared_model, train_loop)
+
+    """
+    torch._C._log_api_usage_once("quantization_api.quantize_pt2e.prepare_qat_pt2e")
+    original_graph_meta = model.meta
+    node_name_to_scope = _get_node_name_to_scope(model)
+    quantizer.transform_for_annotation(model)
+    quantizer.annotate(model)
+    quantizer.validate(model)
+    # Perform fusion after annotate to avoid quantizing ops in the new
+    # subgraph that don't need to be quantized
+    # TODO: only fuse if conv and bn are both configured to be quantized
+    _fuse_conv_bn_qat(model)
+    model = prepare(model, node_name_to_scope, is_qat=True)
+    model.meta.update(original_graph_meta)
+    model = _disallow_eval_train(model)
+    return model
+
+_QUANT_OPS = [
+    torch.ops.quantized_decomposed.quantize_per_tensor.default,
+    torch.ops.quantized_decomposed.quantize_per_tensor.tensor,
+    torch.ops.quantized_decomposed.quantize_per_channel.default,
+]
+def _quant_node_constraint(n: Node) -> bool:
+    """If there is any pure ops between get_attr and quantize op they will be const propagated
+    e.g. get_attr(weight) -> transpose -> quantize -> dequantize*
+    (Note: dequantize op is not going to be constant propagated)
+
+    This filter is added because we don't want to constant fold the things that are not
+    related to quantization
+    """
+    return n.op == "call_function" and n.target in _QUANT_OPS
+
+def convert_pt2e(
+    model: GraphModule,
+    use_reference_representation: bool = False,
+    fold_quantize: bool = True,
+) -> GraphModule:
+    """Convert a calibrated/trained model to a quantized model
+
+    Args:
+      * `model` (torch.fx.GraphModule): calibrated/trained model
+      * `use_reference_representation` (bool): boolean flag to indicate whether to produce referece representation or not
+      * `fold_quantize` (bool): boolean flag for whether fold the quantize op or not
+
+    Returns:
+        quantized model, either in q/dq representation or reference representation
+
+    Example::
+
+        # prepared_model: the model produced by `prepare_pt2e`/`prepare_qat_pt2e` and calibration/training
+        # `convert_pt2e` produces a quantized model that represents quantized computation with
+        # quantize dequantize ops and fp32 ops by default.
+        # Please refer to
+        # https://pytorch.org/tutorials/prototype/pt2e_quant_ptq_static.html#convert-the-calibrated-model-to-a-quantized-model
+        # for detailed explanation of output quantized model
+        quantized_model = convert_pt2e(prepared_model)
+
+    """  # flake8: noqa
+    torch._C._log_api_usage_once("quantization_api.quantize_pt2e.convert_pt2e")
+    if not isinstance(use_reference_representation, bool):
+        raise ValueError(
+            "Unexpected argument type for `use_reference_representation`, "
+            f"please make sure you intend to pass argument {use_reference_representation} to convert_pt2e")
+    original_graph_meta = model.meta
+    model = _convert_to_reference_decomposed_fx(model)
+    model = _fold_conv_bn_qat(model)
+
+    pm = PassManager([DuplicateDQPass()])
+    model = pm(model).graph_module
+
+    pm = PassManager([PortNodeMetaForQDQ()])
+    model = pm(model).graph_module
+
+    if fold_quantize:
+        constant_fold(model, _quant_node_constraint)
+
+    if use_reference_representation:
+        model = reference_representation_rewrite(model)
+
+    model.meta.update(original_graph_meta)
+    model = _disallow_eval_train(model)
+    return model

shared/package-files/d1/d13edbbfb3adb0315c81e9effc52e599d49aa0b6313a5fd622696997da7c56cc/blob

@@ -0,0 +1,91 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/as_strided_scatter_ops.h>
+
+namespace at {
+
+
+// aten::as_strided_scatter(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor
+inline at::Tensor as_strided_scatter(const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter::call(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? c10::make_optional(c10::SymInt(*storage_offset)) : c10::nullopt);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor as_strided_scatter(const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter::call(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? c10::make_optional(c10::SymInt(*storage_offset)) : c10::nullopt);
+  }
+}
+
+// aten::as_strided_scatter(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None) -> Tensor
+inline at::Tensor as_strided_scatter_symint(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter::call(self, src, size, stride, storage_offset);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor as_strided_scatter(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter::call(self, src, size, stride, storage_offset);
+  }
+}
+
+// aten::as_strided_scatter.out(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & as_strided_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter_out::call(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? c10::make_optional(c10::SymInt(*storage_offset)) : c10::nullopt, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & as_strided_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter_out::call(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? c10::make_optional(c10::SymInt(*storage_offset)) : c10::nullopt, out);
+  }
+}
+
+// aten::as_strided_scatter.out(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & as_strided_scatter_outf(const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> storage_offset, at::Tensor & out) {
+    return at::_ops::as_strided_scatter_out::call(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? c10::make_optional(c10::SymInt(*storage_offset)) : c10::nullopt, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  at::Tensor & as_strided_scatter_outf(const at::Tensor & self, const at::Tensor & src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> storage_offset, at::Tensor & out) {
+    return at::_ops::as_strided_scatter_out::call(self, src, c10::fromIntArrayRefSlow(size), c10::fromIntArrayRefSlow(stride), storage_offset.has_value() ? c10::make_optional(c10::SymInt(*storage_offset)) : c10::nullopt, out);
+  }
+}
+
+// aten::as_strided_scatter.out(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & as_strided_scatter_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter_out::call(self, src, size, stride, storage_offset, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & as_strided_scatter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset=c10::nullopt) {
+    return at::_ops::as_strided_scatter_out::call(self, src, size, stride, storage_offset, out);
+  }
+}
+
+// aten::as_strided_scatter.out(Tensor self, Tensor src, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & as_strided_scatter_symint_outf(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset, at::Tensor & out) {
+    return at::_ops::as_strided_scatter_out::call(self, src, size, stride, storage_offset, out);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  at::Tensor & as_strided_scatter_outf(const at::Tensor & self, const at::Tensor & src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional<c10::SymInt> storage_offset, at::Tensor & out) {
+    return at::_ops::as_strided_scatter_out::call(self, src, size, stride, storage_offset, out);
+  }
+}
+
+}

shared/package-files/d1/d13f49c7092a5e91accc67dcaecb71272459ced57d551b05a957068437049a13/blob

@@ -0,0 +1,72 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include "arrow/util/span.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow::util {
+/**
+ * A secure string that ensures the wrapped string is cleared from memory on
+ * deconstruction. This class can only be created from std::string that are securely
+ * erased after creation.
+ *
+ * Note: This class does not provide a constructor / assignment operator that copies a
+ * std::string because that would allow code to create a SecureString while accidentally
+ * not noticing the need to securely erasing the argument after invoking the constructor /
+ * calling the assignment operator.
+ */
+class ARROW_EXPORT SecureString {
+ public:
+  SecureString() = default;
+  SecureString(SecureString&&) noexcept;
+  SecureString(const SecureString&) = default;
+  explicit SecureString(std::string&&) noexcept;
+  explicit SecureString(size_t, char) noexcept;
+
+  SecureString& operator=(SecureString&&) noexcept;
+  SecureString& operator=(const SecureString&);
+  SecureString& operator=(std::string&&) noexcept;
+
+  bool operator==(const SecureString&) const;
+  bool operator!=(const SecureString&) const;
+
+  ~SecureString() { Dispose(); }
+
+  [[nodiscard]] bool empty() const;
+  [[nodiscard]] std::size_t size() const;
+  [[nodiscard]] std::size_t length() const;
+  [[nodiscard]] std::size_t capacity() const;
+
+  [[nodiscard]] span<uint8_t> as_span();
+  [[nodiscard]] span<const uint8_t> as_span() const;
+  [[nodiscard]] std::string_view as_view() const;
+
+  void Dispose();
+
+  static void SecureClear(std::string*);
+  static void SecureClear(uint8_t* data, size_t size);
+
+ private:
+  std::string secret_;
+};
+
+}  // namespace arrow::util