Add files using upload-large-folder tool

.gitattributes

@@ -5356,3 +5356,34 @@ cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/host-windows-x64/TimelineUIU
 cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/host-windows-x64/TimelineWidget.dll filter=lfs diff=lfs merge=lfs -text
 cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/host-windows-x64/ucrtbase.dll filter=lfs diff=lfs merge=lfs -text
 cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/concrt140.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140_2.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/ucrtbase.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/vccorlib140.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/concrt140.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140_2.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/ucrtbase.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/vccorlib140.dll filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/CudaGpuInfoDumper filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.0 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.1 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.2 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.0 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.1 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.2 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.3 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.4 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.5 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.6 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.7 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.8 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.12.4 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.0.187 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.1 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libLinuxKeyboardInterceptorProxy.so filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvlog.so filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvperf_grfx_host.so filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libsqlite3.so.0 filter=lfs diff=lfs merge=lfs -text
+cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libToolsInjection64.so filter=lfs diff=lfs merge=lfs -text

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/msvcp140_2.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/ucrtbase.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib32/vccorlib140.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/concrt140.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/msvcp140_2.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/ucrtbase.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/lib64/vccorlib140.dll

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/CudaGpuInfoDumper

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libLinuxKeyboardInterceptorProxy.so

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libToolsInjection64.so

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.0

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.1

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.10.2

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.0

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.1

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.2

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.3

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.4

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.5

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.6

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.7

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.11.8

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libcupti.so.12.4

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.0.187

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libelf.so.1

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvlog.so

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libnvperf_grfx_host.so

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

cuda_toolkit/nsight-systems/nsight-systems/2023.4.4/target-linux-x64/libsqlite3.so.0

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

git/usr/share/perl5/core_perl/Tie/Memoize.pm

@@ -0,0 +1,128 @@
+use strict;
+package Tie::Memoize;
+use Tie::Hash;
+our @ISA = 'Tie::ExtraHash';
+our $VERSION = '1.1';
+
+our $exists_token = \undef;
+
+sub croak {require Carp; goto &Carp::croak}
+
+# Format: [0: STORAGE, 1: EXISTS-CACHE, 2: FETCH_function;
+#	   3: EXISTS_function, 4: DATA, 5: EXISTS_different ]
+
+sub FETCH {
+  my ($h,$key) = ($_[0][0], $_[1]);
+  my $res = $h->{$key};
+  return $res if defined $res;	# Shortcut if accessible
+  return $res if exists $h->{$key}; # Accessible, but undef
+  my $cache = $_[0][1]{$key};
+  return if defined $cache and not $cache; # Known to not exist
+  my @res = $_[0][2]->($key, $_[0][4]);	# Autoload
+  $_[0][1]{$key} = 0, return unless @res; # Cache non-existence
+  delete $_[0][1]{$key};	# Clear existence cache, not needed any more
+  $_[0][0]{$key} = $res[0];	# Store data and return
+}
+
+sub EXISTS   {
+  my ($a,$key) = (shift, shift);
+  return 1 if exists $a->[0]{$key}; # Have data
+  my $cache = $a->[1]{$key};
+  return $cache if defined $cache; # Existence cache
+  my @res = $a->[3]($key,$a->[4]);
+  $a->[1]{$key} = 0, return unless @res; # Cache non-existence
+  # Now we know it exists
+  return ($a->[1]{$key} = 1) if $a->[5]; # Only existence reported
+  # Now know the value
+  $a->[0]{$key} = $res[0];    # Store data
+  return 1
+}
+
+sub TIEHASH  {
+  croak 'syntax: tie %hash, \'Tie::AutoLoad\', \&fetch_subr' if @_ < 2;
+  croak 'syntax: tie %hash, \'Tie::AutoLoad\', \&fetch_subr, $data, \&exists_subr, \%data_cache, \%existence_cache' if @_ > 6;
+  push @_, undef if @_ < 3;	# Data
+  push @_, $_[1] if @_ < 4;	# exists
+  push @_, {} while @_ < 6;	# initial value and caches
+  bless [ @_[4,5,1,3,2], $_[1] ne $_[3]], $_[0]
+}
+
+1;
+
+=head1 NAME
+
+Tie::Memoize - add data to hash when needed
+
+=head1 SYNOPSIS
+
+  require Tie::Memoize;
+  tie %hash, 'Tie::Memoize',
+      \&fetch,			# The rest is optional
+      $DATA, \&exists,
+      {%ini_value}, {%ini_existence};
+
+=head1 DESCRIPTION
+
+This package allows a tied hash to autoload its values on the first access,
+and to use the cached value on the following accesses.
+
+Only read-accesses (via fetching the value or C<exists>) result in calls to
+the functions; the modify-accesses are performed as on a normal hash.
+
+The required arguments during C<tie> are the hash, the package, and
+the reference to the C<FETCH>ing function.  The optional arguments are
+an arbitrary scalar $data, the reference to the C<EXISTS> function,
+and initial values of the hash and of the existence cache.
+
+Both the C<FETCH>ing function and the C<EXISTS> functions have the
+same signature: the arguments are C<$key, $data>; $data is the same
+value as given as argument during tie()ing.  Both functions should
+return an empty list if the value does not exist.  If C<EXISTS>
+function is different from the C<FETCH>ing function, it should return
+a TRUE value on success.  The C<FETCH>ing function should return the
+intended value if the key is valid.
+
+=head1 Inheriting from B<Tie::Memoize>
+
+The structure of the tied() data is an array reference with elements
+
+  0:  cache of known values
+  1:  cache of known existence of keys
+  2:  FETCH  function
+  3:  EXISTS function
+  4:  $data
+
+The rest is for internal usage of this package.  In particular, if
+TIEHASH is overwritten, it should call SUPER::TIEHASH.
+
+=head1 EXAMPLE
+
+  sub slurp {
+    my ($key, $dir) = shift;
+    open my $h, '<', "$dir/$key" or return;
+    local $/; <$h>			# slurp it all
+  }
+  sub exists { my ($key, $dir) = shift; return -f "$dir/$key" }
+
+  tie %hash, 'Tie::Memoize', \&slurp, $directory, \&exists,
+      { fake_file1 => $content1, fake_file2 => $content2 },
+      { pretend_does_not_exists => 0, known_to_exist => 1 };
+
+This example treats the slightly modified contents of $directory as a
+hash.  The modifications are that the keys F<fake_file1> and
+F<fake_file2> fetch values $content1 and $content2, and
+F<pretend_does_not_exists> will never be accessed.  Additionally, the
+existence of F<known_to_exist> is never checked (so if it does not
+exists when its content is needed, the user of %hash may be confused).
+
+=head1 BUGS
+
+FIRSTKEY and NEXTKEY methods go through the keys which were already read,
+not all the possible keys of the hash.
+
+=head1 AUTHOR
+
+Ilya Zakharevich L<mailto:perl-module-hash-memoize@ilyaz.org>.
+
+=cut
+

git/usr/share/perl5/core_perl/Tie/RefHash.pm

@@ -0,0 +1,367 @@
+package Tie::RefHash; # git description: v1.40-9-g23812d9
+# ABSTRACT: Use references as hash keys
+
+our $VERSION = '1.41';
+
+#pod =head1 SYNOPSIS
+#pod
+#pod     require 5.004;
+#pod     use Tie::RefHash;
+#pod     tie HASHVARIABLE, 'Tie::RefHash', LIST;
+#pod     tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST;
+#pod
+#pod     untie HASHVARIABLE;
+#pod
+#pod =head1 DESCRIPTION
+#pod
+#pod This module provides the ability to use references as hash keys if you
+#pod first C<tie> the hash variable to this module.  Normally, only the
+#pod keys of the tied hash itself are preserved as references; to use
+#pod references as keys in hashes-of-hashes, use Tie::RefHash::Nestable,
+#pod included as part of Tie::RefHash.
+#pod
+#pod It is implemented using the standard perl TIEHASH interface.  Please
+#pod see the C<tie> entry in perlfunc(1) and perltie(1) for more information.
+#pod
+#pod The Nestable version works by looking for hash references being stored
+#pod and converting them to tied hashes so that they too can have
+#pod references as keys.  This will happen without warning whenever you
+#pod store a reference to one of your own hashes in the tied hash.
+#pod
+#pod =head1 EXAMPLE
+#pod
+#pod     use Tie::RefHash;
+#pod     tie %h, 'Tie::RefHash';
+#pod     $a = [];
+#pod     $b = {};
+#pod     $c = \*main;
+#pod     $d = \"gunk";
+#pod     $e = sub { 'foo' };
+#pod     %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5);
+#pod     $a->[0] = 'foo';
+#pod     $b->{foo} = 'bar';
+#pod     for (keys %h) {
+#pod        print ref($_), "\n";
+#pod     }
+#pod
+#pod     tie %h, 'Tie::RefHash::Nestable';
+#pod     $h{$a}->{$b} = 1;
+#pod     for (keys %h, keys %{$h{$a}}) {
+#pod        print ref($_), "\n";
+#pod     }
+#pod
+#pod =head1 THREAD SUPPORT
+#pod
+#pod L<Tie::RefHash> fully supports threading using the C<CLONE> method.
+#pod
+#pod =head1 STORABLE SUPPORT
+#pod
+#pod L<Storable> hooks are provided for semantically correct serialization and
+#pod cloning of tied refhashes.
+#pod
+#pod =head1 AUTHORS
+#pod
+#pod Gurusamy Sarathy <gsar@activestate.com>
+#pod
+#pod Tie::RefHash::Nestable by Ed Avis <ed@membled.com>
+#pod
+#pod =head1 SEE ALSO
+#pod
+#pod perl(1), perlfunc(1), perltie(1)
+#pod
+#pod =cut
+
+use Tie::Hash;
+our @ISA = qw(Tie::Hash);
+use strict;
+use Carp ();
+
+# Tie::RefHash::Weak (until at least 0.09) assumes we define a refaddr()
+# function, so just import the one from Scalar::Util
+use Scalar::Util qw(refaddr);
+
+BEGIN {
+  # determine whether we need to take care of threads
+  use Config ();
+  my $usethreads = $Config::Config{usethreads}; # && exists $INC{"threads.pm"}
+  *_HAS_THREADS = $usethreads ? sub () { 1 } : sub () { 0 };
+  *_HAS_WEAKEN = defined(&Scalar::Util::weaken) ? sub () { 1 } : sub () { 0 };
+}
+
+my (@thread_object_registry, $count); # used by the CLONE method to rehash the keys after their refaddr changed
+
+sub TIEHASH {
+  my $c = shift;
+  my $s = [];
+  bless $s, $c;
+  while (@_) {
+    $s->STORE(shift, shift);
+  }
+
+  if (_HAS_THREADS ) {
+
+    if ( _HAS_WEAKEN ) {
+      # remember the object so that we can rekey it on CLONE
+      push @thread_object_registry, $s;
+      # but make this a weak reference, so that there are no leaks
+      Scalar::Util::weaken( $thread_object_registry[-1] );
+
+      if ( ++$count > 1000 ) {
+        # this ensures we don't fill up with a huge array dead weakrefs
+        @thread_object_registry = grep defined, @thread_object_registry;
+        Scalar::Util::weaken( $_ ) for @thread_object_registry;
+        $count = 0;
+      }
+    } else {
+      $count++; # used in the warning
+    }
+  }
+
+  return $s;
+}
+
+my $storable_format_version = join("/", __PACKAGE__, "0.01");
+
+sub STORABLE_freeze {
+  my ( $self, $is_cloning ) = @_;
+  my ( $refs, $reg ) = @$self;
+  return ( $storable_format_version, [ values %$refs ], $reg || {} );
+}
+
+sub STORABLE_thaw {
+  my ( $self, $is_cloning, $version, $refs, $reg ) = @_;
+  Carp::croak "incompatible versions of Tie::RefHash between freeze and thaw"
+    unless $version eq $storable_format_version;
+
+  @$self = ( {}, $reg );
+  $self->_reindex_keys( $refs );
+}
+
+sub CLONE {
+  my $pkg = shift;
+
+  if ( $count and not _HAS_WEAKEN ) {
+    warn "Tie::RefHash is not threadsafe without Scalar::Util::weaken";
+  }
+
+  # when the thread has been cloned all the objects need to be updated.
+  # dead weakrefs are undefined, so we filter them out
+  @thread_object_registry = grep defined && do { $_->_reindex_keys; 1 }, @thread_object_registry;
+  Scalar::Util::weaken( $_ ) for @thread_object_registry;
+  $count = 0; # we just cleaned up
+}
+
+sub _reindex_keys {
+  my ( $self, $extra_keys ) = @_;
+  # rehash all the ref keys based on their new StrVal
+  %{ $self->[0] } = map +(refaddr($_->[0]) => $_), (values(%{ $self->[0] }), @{ $extra_keys || [] });
+}
+
+sub FETCH {
+  my($s, $k) = @_;
+  if (ref $k) {
+      my $kstr = refaddr($k);
+      if (defined $s->[0]{$kstr}) {
+        $s->[0]{$kstr}[1];
+      }
+      else {
+        undef;
+      }
+  }
+  else {
+      $s->[1]{$k};
+  }
+}
+
+sub STORE {
+  my($s, $k, $v) = @_;
+  if (ref $k) {
+    $s->[0]{refaddr($k)} = [$k, $v];
+  }
+  else {
+    $s->[1]{$k} = $v;
+  }
+  $v;
+}
+
+sub DELETE {
+  my($s, $k) = @_;
+  (ref $k)
+    ? (delete($s->[0]{refaddr($k)}) || [])->[1]
+    : delete($s->[1]{$k});
+}
+
+sub EXISTS {
+  my($s, $k) = @_;
+  (ref $k) ? exists($s->[0]{refaddr($k)}) : exists($s->[1]{$k});
+}
+
+sub FIRSTKEY {
+  my $s = shift;
+  keys %{$s->[0]};  # reset iterator
+  keys %{$s->[1]};  # reset iterator
+  $s->[2] = 0;      # flag for iteration, see NEXTKEY
+  $s->NEXTKEY;
+}
+
+sub NEXTKEY {
+  my $s = shift;
+  my ($k, $v);
+  if (!$s->[2]) {
+    if (($k, $v) = each %{$s->[0]}) {
+      return $v->[0];
+    }
+    else {
+      $s->[2] = 1;
+    }
+  }
+  return each %{$s->[1]};
+}
+
+sub CLEAR {
+  my $s = shift;
+  $s->[2] = 0;
+  %{$s->[0]} = ();
+  %{$s->[1]} = ();
+}
+
+package # hide from PAUSE
+  Tie::RefHash::Nestable;
+our @ISA = 'Tie::RefHash';
+
+sub STORE {
+  my($s, $k, $v) = @_;
+  if (ref($v) eq 'HASH' and not tied %$v) {
+      my @elems = %$v;
+      tie %$v, ref($s), @elems;
+  }
+  $s->SUPER::STORE($k, $v);
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Tie::RefHash - Use references as hash keys
+
+=head1 VERSION
+
+version 1.41
+
+=head1 SYNOPSIS
+
+    require 5.004;
+    use Tie::RefHash;
+    tie HASHVARIABLE, 'Tie::RefHash', LIST;
+    tie HASHVARIABLE, 'Tie::RefHash::Nestable', LIST;
+
+    untie HASHVARIABLE;
+
+=head1 DESCRIPTION
+
+This module provides the ability to use references as hash keys if you
+first C<tie> the hash variable to this module.  Normally, only the
+keys of the tied hash itself are preserved as references; to use
+references as keys in hashes-of-hashes, use Tie::RefHash::Nestable,
+included as part of Tie::RefHash.
+
+It is implemented using the standard perl TIEHASH interface.  Please
+see the C<tie> entry in perlfunc(1) and perltie(1) for more information.
+
+The Nestable version works by looking for hash references being stored
+and converting them to tied hashes so that they too can have
+references as keys.  This will happen without warning whenever you
+store a reference to one of your own hashes in the tied hash.
+
+=head1 EXAMPLE
+
+    use Tie::RefHash;
+    tie %h, 'Tie::RefHash';
+    $a = [];
+    $b = {};
+    $c = \*main;
+    $d = \"gunk";
+    $e = sub { 'foo' };
+    %h = ($a => 1, $b => 2, $c => 3, $d => 4, $e => 5);
+    $a->[0] = 'foo';
+    $b->{foo} = 'bar';
+    for (keys %h) {
+       print ref($_), "\n";
+    }
+
+    tie %h, 'Tie::RefHash::Nestable';
+    $h{$a}->{$b} = 1;
+    for (keys %h, keys %{$h{$a}}) {
+       print ref($_), "\n";
+    }
+
+=head1 THREAD SUPPORT
+
+L<Tie::RefHash> fully supports threading using the C<CLONE> method.
+
+=head1 STORABLE SUPPORT
+
+L<Storable> hooks are provided for semantically correct serialization and
+cloning of tied refhashes.
+
+=head1 SEE ALSO
+
+perl(1), perlfunc(1), perltie(1)
+
+=head1 SUPPORT
+
+Bugs may be submitted through L<the RT bug tracker|https://rt.cpan.org/Public/Dist/Display.html?Name=Tie-RefHash>
+(or L<bug-Tie-RefHash@rt.cpan.org|mailto:bug-Tie-RefHash@rt.cpan.org>).
+
+=head1 AUTHORS
+
+Gurusamy Sarathy <gsar@activestate.com>
+
+Tie::RefHash::Nestable by Ed Avis <ed@membled.com>
+
+=head1 CONTRIBUTORS
+
+=for stopwords Yuval Kogman Karen Etheridge Florian Ragwitz Lukas Mai Jerry D. Hedden tusooa
+
+=over 4
+
+=item *
+
+Yuval Kogman <nothingmuch@woobling.org>
+
+=item *
+
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+Florian Ragwitz <rafl@debian.org>
+
+=item *
+
+Lukas Mai <lukasmai.403@gmail.com>
+
+=item *
+
+Jerry D. Hedden <jdhedden@cpan.org>
+
+=item *
+
+tusooa <tusooa@kazv.moe>
+
+=back
+
+=head1 COPYRIGHT AND LICENCE
+
+This software is copyright (c) 2006 by יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>.
+
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+
+=cut

git/usr/share/perl5/core_perl/Tie/Scalar.pm

@@ -0,0 +1,164 @@
+package Tie::Scalar;
+
+our $VERSION = '1.06';
+
+=head1 NAME
+
+Tie::Scalar, Tie::StdScalar - base class definitions for tied scalars
+
+=head1 SYNOPSIS
+
+    package NewScalar;
+    require Tie::Scalar;
+
+    @ISA = qw(Tie::Scalar);
+
+    sub FETCH { ... }		# Provide a needed method
+    sub TIESCALAR { ... }	# Overrides inherited method
+
+
+    package NewStdScalar;
+    require Tie::Scalar;
+
+    @ISA = qw(Tie::StdScalar);
+
+    # All methods provided by default, so define
+    # only what needs be overridden
+    sub FETCH { ... }
+
+
+    package main;
+
+    tie $new_scalar, 'NewScalar';
+    tie $new_std_scalar, 'NewStdScalar';
+
+=head1 DESCRIPTION
+
+This module provides some skeletal methods for scalar-tying classes. See
+L<perltie> for a list of the functions required in tying a scalar to a
+package. The basic B<Tie::Scalar> package provides a C<new> method, as well
+as methods C<TIESCALAR>, C<FETCH> and C<STORE>. The B<Tie::StdScalar>
+package provides all the methods specified in  L<perltie>. It inherits from
+B<Tie::Scalar> and causes scalars tied to it to behave exactly like the
+built-in scalars, allowing for selective overloading of methods. The C<new>
+method is provided as a means of legacy support for classes that forget to
+provide their own C<TIESCALAR> method.
+
+For developers wishing to write their own tied-scalar classes, the methods
+are summarized below. The L<perltie> section not only documents these, but
+has sample code as well:
+
+=over 4
+
+=item TIESCALAR classname, LIST
+
+The method invoked by the command C<tie $scalar, classname>. Associates a new
+scalar instance with the specified class. C<LIST> would represent additional
+arguments (along the lines of L<AnyDBM_File> and compatriots) needed to
+complete the association.
+
+=item FETCH this
+
+Retrieve the value of the tied scalar referenced by I<this>.
+
+=item STORE this, value
+
+Store data I<value> in the tied scalar referenced by I<this>.
+
+=item DESTROY this
+
+Free the storage associated with the tied scalar referenced by I<this>.
+This is rarely needed, as Perl manages its memory quite well. But the
+option exists, should a class wish to perform specific actions upon the
+destruction of an instance.
+
+=back
+
+=head2 Tie::Scalar vs Tie::StdScalar
+
+C<< Tie::Scalar >> provides all the necessary methods, but one should realize
+they do not do anything useful. Calling C<< Tie::Scalar::FETCH >> or 
+C<< Tie::Scalar::STORE >> results in a (trappable) croak. And if you inherit
+from C<< Tie::Scalar >>, you I<must> provide either a C<< new >> or a
+C<< TIESCALAR >> method. 
+
+If you are looking for a class that does everything for you that you don't
+define yourself, use the C<< Tie::StdScalar >> class, not the
+C<< Tie::Scalar >> one.
+
+=head1 MORE INFORMATION
+
+The L<perltie> section uses a good example of tying scalars by associating
+process IDs with priority.
+
+=cut
+
+use Carp;
+use warnings::register;
+
+sub new {
+    my $pkg = shift;
+    $pkg->TIESCALAR(@_);
+}
+
+# Legacy support for new(), a la Tie::Hash
+
+sub TIESCALAR {
+    my $pkg = shift;
+    my $pkg_new = $pkg -> can ('new');
+
+    if ($pkg_new and $pkg ne __PACKAGE__) {
+        my $my_new = __PACKAGE__ -> can ('new');
+        if ($pkg_new == $my_new) {  
+            #
+            # Prevent recursion
+            #
+            croak "$pkg must define either a TIESCALAR() or a new() method";
+        }
+
+	warnings::warnif ("WARNING: calling ${pkg}->new since " .
+                          "${pkg}->TIESCALAR is missing");
+	$pkg -> new (@_);
+    }
+    else {
+	croak "$pkg doesn't define a TIESCALAR method";
+    }
+}
+
+sub FETCH {
+    my $pkg = ref $_[0];
+    croak "$pkg doesn't define a FETCH method";
+}
+
+sub STORE {
+    my $pkg = ref $_[0];
+    croak "$pkg doesn't define a STORE method";
+}
+
+#
+# The Tie::StdScalar package provides scalars that behave exactly like
+# Perl's built-in scalars. Good base to inherit from, if you're only going to
+# tweak a small bit.
+#
+package Tie::StdScalar;
+@ISA = qw(Tie::Scalar);
+
+sub TIESCALAR {
+    my $class = shift;
+    my $instance = @_ ? shift : undef;
+    return bless \$instance => $class;
+}
+
+sub FETCH {
+    return ${$_[0]};
+}
+
+sub STORE {
+    ${$_[0]} = $_[1];
+}
+
+sub DESTROY {
+    undef ${$_[0]};
+}
+
+1;

git/usr/share/perl5/core_perl/Tie/StdHandle.pm

@@ -0,0 +1,71 @@
+package Tie::StdHandle; 
+
+use strict;
+
+use Tie::Handle;
+our @ISA = 'Tie::Handle';
+our $VERSION = '4.6';
+
+=head1 NAME
+
+Tie::StdHandle - base class definitions for tied handles
+
+=head1 SYNOPSIS
+
+    package NewHandle;
+    require Tie::Handle;
+
+    @ISA = qw(Tie::Handle);
+
+    sub READ { ... }		# Provide a needed method
+    sub TIEHANDLE { ... }	# Overrides inherited method
+
+
+    package main;
+
+    tie *FH, 'NewHandle';
+
+=head1 DESCRIPTION
+
+The B<Tie::StdHandle> package provide most methods for file handles described
+in L<perltie> (the exceptions are C<UNTIE> and C<DESTROY>).  It causes tied
+file handles to behave exactly like standard file handles and allow for
+selective overwriting of methods.
+
+=cut
+
+sub TIEHANDLE 
+{
+ my $class = shift;
+ my $fh    = \do { local *HANDLE};
+ bless $fh,$class;
+ $fh->OPEN(@_) if (@_);
+ return $fh;
+}
+
+sub EOF     { eof($_[0]) }
+sub TELL    { tell($_[0]) }
+sub FILENO  { fileno($_[0]) }
+sub SEEK    { seek($_[0],$_[1],$_[2]) }
+sub CLOSE   { close($_[0]) }
+sub BINMODE { &CORE::binmode(shift, @_) }
+
+sub OPEN
+{
+ $_[0]->CLOSE if defined($_[0]->FILENO);
+ @_ == 2 ? open($_[0], $_[1]) : open($_[0], $_[1], $_[2]);
+}
+
+sub READ     { &CORE::read(shift, \shift, @_) }
+sub READLINE { my $fh = $_[0]; <$fh> }
+sub GETC     { getc($_[0]) }
+
+sub WRITE
+{
+ my $fh = $_[0];
+ local $\; # don't print any line terminator
+ print $fh substr($_[1], $_[3], $_[2]);
+}
+
+
+1;

git/usr/share/perl5/core_perl/Tie/SubstrHash.pm

@@ -0,0 +1,211 @@
+package Tie::SubstrHash 1.01;
+
+=head1 NAME
+
+Tie::SubstrHash - Fixed-table-size, fixed-key-length hashing
+
+=head1 SYNOPSIS
+
+    require Tie::SubstrHash;
+
+    tie %myhash, 'Tie::SubstrHash', $key_len, $value_len, $table_size;
+
+=head1 DESCRIPTION
+
+The B<Tie::SubstrHash> package provides a hash-table-like interface to
+an array of determinate size, with constant key size and record size.
+
+Upon tying a new hash to this package, the developer must specify the
+size of the keys that will be used, the size of the value fields that the
+keys will index, and the size of the overall table (in terms of key-value
+pairs, not size in hard memory). I<These values will not change for the
+duration of the tied hash>. The newly-allocated hash table may now have
+data stored and retrieved. Efforts to store more than C<$table_size>
+elements will result in a fatal error, as will efforts to store a value
+not exactly C<$value_len> characters in length, or reference through a
+key not exactly C<$key_len> characters in length. While these constraints
+may seem excessive, the result is a hash table using much less internal
+memory than an equivalent freely-allocated hash table.
+
+=head1 CAVEATS
+
+Because the current implementation uses the table and key sizes for the
+hashing algorithm, there is no means by which to dynamically change the
+value of any of the initialization parameters.
+
+The hash does not support exists().
+
+=cut
+
+use strict;
+use warnings;
+no warnings 'experimental::builtin';
+
+use Carp;
+
+sub TIEHASH {
+    my ($pack, $klen, $vlen, $tsize) = @_;
+    my $rlen = 1 + $klen + $vlen;
+    $tsize = [$tsize, findgteprime($tsize * 1.1)]; # Allow 10% empty.
+    my $self = bless ["\0", $klen, $vlen, $tsize, $rlen, 0, -1];
+    $self->[0] x= $rlen * $tsize->[1];
+    $self;
+}
+
+sub CLEAR {
+    my ($self) = @_;
+    $self->[0] = "\0" x ($self->[4] * $self->[3][1]);
+    $self->[5] =  0;
+    $self->[6] = -1;
+}
+
+sub FETCH {
+    my ($self, $key) = @_;
+    my (undef, $klen, $vlen, $tsize, $rlen) = @$self;
+    my $hashbase = my $hash = hashkey($key, $klen, $tsize);
+    while (1) {
+        my $offset = $hash * $rlen;
+        my $record = substr($self->[0], $offset, $rlen);
+        if (ord($record) == 0) {
+            return undef;
+        }
+        elsif (ord($record) == 1) {
+        }
+        elsif (substr($record, 1, $klen) eq $key) {
+            return substr($record, 1+$klen, $vlen);
+        }
+        $hash = rehash($hash, $hashbase, $tsize);
+    }
+}
+
+sub STORE {
+    my ($self, $key, $val) = @_;
+    my (undef, $klen, $vlen, $tsize, $rlen) = @$self;
+    croak("Table is full ($tsize->[0] elements)") if $self->[5] > $tsize->[0];
+    croak(qq/Value "$val" is not $vlen characters long/)
+        if length($val) != $vlen;
+    my $writeoffset;
+
+    my $hashbase = my $hash = hashkey($key, $klen, $tsize);
+    while (1) {
+        my $offset = $hash * $rlen;
+        my $record = substr($self->[0], $offset, $rlen);
+        if (ord($record) == 0) {
+            $record = "\2". $key . $val;
+            die "panic" unless length($record) == $rlen;
+            $writeoffset //= $offset;
+            substr($self->[0], $writeoffset, $rlen) = $record;
+            ++$self->[5];
+            return;
+        }
+        elsif (ord($record) == 1) {
+            $writeoffset //= $offset;
+        }
+        elsif (substr($record, 1, $klen) eq $key) {
+            $record = "\2". $key . $val;
+            die "panic" unless length($record) == $rlen;
+            substr($self->[0], $offset, $rlen) = $record;
+            return;
+        }
+        $hash = rehash($hash, $hashbase, $tsize);
+    }
+}
+
+sub DELETE {
+    my ($self, $key) = @_;
+    my (undef, $klen, $vlen, $tsize, $rlen) = @$self;
+    my $hashbase = my $hash = hashkey($key, $klen, $tsize);
+    while (1) {
+        my $offset = $hash * $rlen;
+        my $record = substr($self->[0], $offset, $rlen);
+        if (ord($record) == 0) {
+            return undef;
+        }
+        elsif (ord($record) == 1) {
+        }
+        elsif (substr($record, 1, $klen) eq $key) {
+            substr($self->[0], $offset, 1) = "\1";
+            return substr($record, 1+$klen, $vlen);
+            --$self->[5];
+        }
+        $hash = rehash($hash, $hashbase, $tsize);
+    }
+}
+
+sub FIRSTKEY {
+    my ($self) = @_;
+    $self->[6] = -1;
+    goto &NEXTKEY;
+}
+
+sub NEXTKEY {
+    my ($self) = @_;
+    my (undef, $klen, $vlen, $tsize, $rlen, $entries, $iterix) = @$self;
+    for (++$iterix; $iterix < $tsize->[1]; ++$iterix) {
+        next unless substr($self->[0], $iterix * $rlen, 1) eq "\2";
+        $self->[6] = $iterix;
+        return substr($self->[0], $iterix * $rlen + 1, $klen);
+    }
+    $self->[6] = -1;
+    undef;
+}
+
+sub EXISTS {
+    croak "Tie::SubstrHash does not support exists()";
+}
+
+sub hashkey {
+    my ($key, $klen, $tsize) = @_;
+    croak(qq/Key "$key" is not $klen characters long/)
+        if length($key) != $klen;
+    my $hash = 2;
+    for (unpack('C*', $key)) {
+        $hash = $hash * 33 + $_;
+        $hash = _hashwrap($hash, $tsize) if $hash >= 1e13;
+    }
+    $hash = _hashwrap($hash, $tsize) if $hash >= $tsize->[1];
+    $hash ||= 1;
+    return $hash;
+}
+
+sub _hashwrap {
+    my ($hash, $tsize) = @_;
+    return $hash - int($hash / $tsize->[1]) * $tsize->[1];
+}
+
+sub rehash {
+    my ($hash, $hashbase, $tsize) = @_;
+    $hash += $hashbase;
+    $hash -= $tsize->[1] if $hash >= $tsize->[1];
+    return $hash;
+}
+
+# See:
+#
+# http://www-groups.dcs.st-andrews.ac.uk/~history/HistTopics/Prime_numbers.html
+#
+
+sub findgteprime { # find the smallest prime integer greater than or equal to
+    use integer;
+
+    my $num = builtin::ceil(shift);
+    return 2 if $num <= 2;
+
+    $num++ unless $num % 2;
+    my $sqrtnum = int sqrt $num;
+    my $sqrtnumsquared = $sqrtnum * $sqrtnum;
+
+  NUM:
+    for (;; $num += 2) {
+        if ($sqrtnumsquared < $num) {
+            $sqrtnum++;
+            $sqrtnumsquared = $sqrtnum * $sqrtnum;
+        }
+        for (my $i = 3; $i <= $sqrtnum; $i += 2) {
+            next NUM unless $num % $i;
+        }
+        return $num;
+    }
+}
+
+1;

git/usr/share/perl5/core_perl/Time/Local.pm

@@ -0,0 +1,547 @@
+package Time::Local;
+
+use strict;
+
+use Carp ();
+use Exporter;
+
+our $VERSION = '1.35';
+
+use parent 'Exporter';
+
+our @EXPORT    = qw( timegm timelocal );
+our @EXPORT_OK = qw(
+    timegm_modern
+    timelocal_modern
+    timegm_nocheck
+    timelocal_nocheck
+    timegm_posix
+    timelocal_posix
+);
+
+my @MonthDays = ( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
+
+# Determine breakpoint for rolling century
+my $ThisYear    = ( localtime() )[5];
+my $Breakpoint  = ( $ThisYear + 50 ) % 100;
+my $NextCentury = $ThisYear - $ThisYear % 100;
+$NextCentury += 100 if $Breakpoint < 50;
+my $Century = $NextCentury - 100;
+my $SecOff  = 0;
+
+my ( %Options, %Cheat );
+
+use constant SECS_PER_MINUTE => 60;
+use constant SECS_PER_HOUR   => 3600;
+use constant SECS_PER_DAY    => 86400;
+
+my $MaxDay;
+if ( $] < 5.012000 ) {
+    require Config;
+    ## no critic (Variables::ProhibitPackageVars)
+
+    my $MaxInt;
+    if ( $^O eq 'MacOS' ) {
+
+        # time_t is unsigned...
+        $MaxInt = ( 1 << ( 8 * $Config::Config{ivsize} ) )
+            - 1;    ## no critic qw(ProhibitPackageVars)
+    }
+    else {
+        $MaxInt
+            = ( ( 1 << ( 8 * $Config::Config{ivsize} - 2 ) ) - 1 ) * 2
+            + 1;    ## no critic qw(ProhibitPackageVars)
+    }
+
+    $MaxDay = int( ( $MaxInt - ( SECS_PER_DAY / 2 ) ) / SECS_PER_DAY ) - 1;
+}
+else {
+    # recent localtime()'s limit is the year 2**31
+    $MaxDay = 365 * ( 2**31 );
+
+    # On (some?) 32-bit platforms this overflows and we end up with a negative
+    # $MaxDay, which totally breaks this module. This is the old calculation
+    # we used from the days before Perl always had 64-bit time_t.
+    if ( $MaxDay < 0 ) {
+        require Config;
+        ## no critic (Variables::ProhibitPackageVars)
+        my $max_int
+            = ( ( 1 << ( 8 * $Config::Config{intsize} - 2 ) ) - 1 ) * 2 + 1;
+        $MaxDay
+            = int( ( $max_int - ( SECS_PER_DAY / 2 ) ) / SECS_PER_DAY ) - 1;
+    }
+}
+
+# Determine the EPOC day for this machine
+my $Epoc = 0;
+if ( $^O eq 'vos' ) {
+
+    # work around posix-977 -- VOS doesn't handle dates in the range
+    # 1970-1980.
+    $Epoc = _daygm( 0, 0, 0, 1, 0, 70, 4, 0 );
+}
+elsif ( $^O eq 'MacOS' ) {
+    $MaxDay *= 2;    # time_t unsigned ... quick hack?
+                     # MacOS time() is seconds since 1 Jan 1904, localtime
+                     # so we need to calculate an offset to apply later
+    $Epoc   = 693901;
+    $SecOff = timelocal( localtime(0) ) - timelocal( gmtime(0) );
+    $Epoc += _daygm( gmtime(0) );
+}
+else {
+    $Epoc = _daygm( gmtime(0) );
+}
+
+%Cheat = ();    # clear the cache as epoc has changed
+
+sub _daygm {
+
+    # This is written in such a byzantine way in order to avoid
+    # lexical variables and sub calls, for speed
+    return $_[3] + (
+        $Cheat{ pack( 'ss', @_[ 4, 5 ] ) } ||= do {
+            my $month = ( $_[4] + 10 ) % 12;
+            my $year  = $_[5] + 1900 - int( $month / 10 );
+
+            ( ( 365 * $year )
+                + int( $year / 4 )
+                    - int( $year / 100 )
+                    + int( $year / 400 )
+                    + int( ( ( $month * 306 ) + 5 ) / 10 ) )
+                - $Epoc;
+        }
+    );
+}
+
+sub _timegm {
+    my $sec
+        = $SecOff + $_[0]
+        + ( SECS_PER_MINUTE * $_[1] )
+        + ( SECS_PER_HOUR * $_[2] );
+
+    return $sec + ( SECS_PER_DAY * &_daygm );
+}
+
+sub timegm {
+    my ( $sec, $min, $hour, $mday, $month, $year ) = @_;
+    my $subsec = $sec - int($sec);
+    $sec = int($sec);
+
+    if ( $Options{no_year_munging} ) {
+        $year -= 1900;
+    }
+    elsif ( !$Options{posix_year} ) {
+        if ( $year >= 1000 ) {
+            $year -= 1900;
+        }
+        elsif ( $year < 100 and $year >= 0 ) {
+            $year += ( $year > $Breakpoint ) ? $Century : $NextCentury;
+        }
+    }
+
+    unless ( $Options{no_range_check} ) {
+        Carp::croak("Month '$month' out of range 0..11")
+            if $month > 11
+            or $month < 0;
+
+        my $md = $MonthDays[$month];
+        ++$md
+            if $month == 1 && _is_leap_year( $year + 1900 );
+
+        Carp::croak("Day '$mday' out of range 1..$md")
+            if $mday > $md or $mday < 1;
+        Carp::croak("Hour '$hour' out of range 0..23")
+            if $hour > 23 or $hour < 0;
+        Carp::croak("Minute '$min' out of range 0..59")
+            if $min > 59 or $min < 0;
+        Carp::croak("Second '$sec' out of range 0..59")
+            if $sec >= 60 or $sec < 0;
+    }
+
+    my $days = _daygm( undef, undef, undef, $mday, $month, $year );
+
+    if ( abs($days) > $MaxDay && !$Options{no_range_check} ) {
+        my $msg = "Day too big - abs($days) > $MaxDay\n";
+
+        $year += 1900;
+        $msg
+            .= "Cannot handle date ($sec, $min, $hour, $mday, $month, $year)";
+
+        Carp::croak($msg);
+    }
+
+    # Adding in the $subsec value last seems to prevent floating point errors
+    # from creeping in.
+    return (
+        (
+                  $sec + $SecOff
+                + ( SECS_PER_MINUTE * $min )
+                + ( SECS_PER_HOUR * $hour )
+                + ( SECS_PER_DAY * $days )
+        ) + $subsec
+    );
+}
+
+sub _is_leap_year {
+    return 0 if $_[0] % 4;
+    return 1 if $_[0] % 100;
+    return 0 if $_[0] % 400;
+
+    return 1;
+}
+
+sub timegm_nocheck {
+    local $Options{no_range_check} = 1;
+    return &timegm;
+}
+
+sub timegm_modern {
+    local $Options{no_year_munging} = 1;
+    return &timegm;
+}
+
+sub timegm_posix {
+    local $Options{posix_year} = 1;
+    return &timegm;
+}
+
+sub timelocal {
+    my $sec    = shift;
+    my $subsec = $sec - int($sec);
+    $sec = int($sec);
+    unshift @_, $sec;
+
+    my $ref_t         = &timegm;
+    my $loc_for_ref_t = _timegm( localtime($ref_t) );
+
+    my $zone_off = $loc_for_ref_t - $ref_t
+        or return $loc_for_ref_t + $subsec;
+
+    # Adjust for timezone
+    my $loc_t = $ref_t - $zone_off;
+
+    # Are we close to a DST change or are we done
+    my $dst_off = $ref_t - _timegm( localtime($loc_t) );
+
+    # If this evaluates to true, it means that the value in $loc_t is
+    # the _second_ hour after a DST change where the local time moves
+    # backward.
+    if (
+        !$dst_off
+        && ( ( $ref_t - SECS_PER_HOUR )
+            - _timegm( localtime( $loc_t - SECS_PER_HOUR ) ) < 0 )
+    ) {
+        return ( $loc_t - SECS_PER_HOUR ) + $subsec;
+    }
+
+    # Adjust for DST change
+    $loc_t += $dst_off;
+
+    return $loc_t + $subsec if $dst_off > 0;
+
+    # If the original date was a non-existent gap in a forward DST jump, we
+    # should now have the wrong answer - undo the DST adjustment
+    my ( $s, $m, $h ) = localtime($loc_t);
+    $loc_t -= $dst_off if $s != $_[0] || $m != $_[1] || $h != $_[2];
+
+    return $loc_t + $subsec;
+}
+
+sub timelocal_nocheck {
+    local $Options{no_range_check} = 1;
+    return &timelocal;
+}
+
+sub timelocal_modern {
+    local $Options{no_year_munging} = 1;
+    return &timelocal;
+}
+
+sub timelocal_posix {
+    local $Options{posix_year} = 1;
+    return &timelocal;
+}
+
+1;
+
+# ABSTRACT: Efficiently compute time from local and GMT time
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Time::Local - Efficiently compute time from local and GMT time
+
+=head1 VERSION
+
+version 1.35
+
+=head1 SYNOPSIS
+
+    use Time::Local qw( timelocal_posix timegm_posix );
+
+    my $time = timelocal_posix( $sec, $min, $hour, $mday, $mon, $year );
+    my $time = timegm_posix( $sec, $min, $hour, $mday, $mon, $year );
+
+=head1 DESCRIPTION
+
+This module provides functions that are the inverse of built-in perl functions
+C<localtime()> and C<gmtime()>. They accept a date as a six-element array, and
+return the corresponding C<time(2)> value in seconds since the system epoch
+(Midnight, January 1, 1970 GMT on Unix, for example). This value can be
+positive or negative, though POSIX only requires support for positive values,
+so dates before the system's epoch may not work on all operating systems.
+
+It is worth drawing particular attention to the expected ranges for the values
+provided. The value for the day of the month is the actual day (i.e. 1..31),
+while the month is the number of months since January (0..11). This is
+consistent with the values returned from C<localtime()> and C<gmtime()>.
+
+=head1 FUNCTIONS
+
+=head2 C<timelocal_posix()> and C<timegm_posix()>
+
+I<Since version 1.30.>
+
+These functions are the exact inverse of Perl's built-in C<localtime> and
+C<gmtime> functions. That means that calling C<< timelocal_posix(
+localtime($value) ) >> will always give you the same C<$value> you started
+with. The same applies to C<< timegm_posix( gmtime($value) ) >>.
+
+The one exception is when the value returned from C<localtime()> represents an
+ambiguous local time because of a DST change. See the documentation below for
+more details.
+
+These functions expect the year value to be the number of years since 1900,
+which is what the C<localtime()> and C<gmtime()> built-ins returns.
+
+They perform range checking by default on the input C<$sec>, C<$min>, C<$hour>,
+C<$mday>, and C<$mon> values and will croak (using C<Carp::croak()>) if given a
+value outside the allowed ranges.
+
+While it would be nice to make this the default behavior, that would almost
+certainly break a lot of code, so you must explicitly import these functions
+and use them instead of the default C<timelocal()> and C<timegm()>.
+
+You are B<strongly> encouraged to use these functions in any new code which
+uses this module. It will almost certainly make your code's behavior less
+surprising.
+
+=head2 C<timelocal_modern()> and C<timegm_modern()>
+
+I<Since version 1.27.>
+
+When C<Time::Local> was first written, it was a common practice to represent
+years as a two-digit value like C<99> for C<1999> or C<1> for C<2001>. This
+caused all sorts of problems (google "Y2K problem" if you're very young) and
+developers eventually realized that this was a terrible idea.
+
+The default exports of C<timelocal()> and C<timegm()> do a complicated
+calculation when given a year value less than 1000. This leads to surprising
+results in many cases. See L</Year Value Interpretation> for details.
+
+The C<time*_modern()> functions do not do this year munging and simply take the
+year value as provided.
+
+They perform range checking by default on the input C<$sec>, C<$min>, C<$hour>,
+C<$mday>, and C<$mon> values and will croak (using C<Carp::croak()>) if given a
+value outside the allowed ranges.
+
+=head2 C<timelocal()> and C<timegm()>
+
+This module exports two functions by default, C<timelocal()> and C<timegm()>.
+
+They perform range checking by default on the input C<$sec>, C<$min>, C<$hour>,
+C<$mday>, and C<$mon> values and will croak (using C<Carp::croak()>) if given a
+value outside the allowed ranges.
+
+B<Warning: The year value interpretation that these functions and their nocheck
+variants use will almost certainly lead to bugs in your code, if not now, then
+in the future. You are strongly discouraged from using these in new code, and
+you should convert old code to using either the C<*_posix> or C<*_modern>
+functions if possible.>
+
+=head2 C<timelocal_nocheck()> and C<timegm_nocheck()>
+
+If you are working with data you know to be valid, you can use the "nocheck"
+variants, C<timelocal_nocheck()> and C<timegm_nocheck()>. These variants must
+be explicitly imported.
+
+If you supply data which is not valid (month 27, second 1,000) the results will
+be unpredictable (so don't do that).
+
+Note that my benchmarks show that this is just a 3% speed increase over the
+checked versions, so unless calling C<Time::Local> is the hottest spot in your
+application, using these nocheck variants is unlikely to have much impact on
+your application.
+
+=head2 Year Value Interpretation
+
+B<This does not apply to the C<*_posix> or C<*_modern> functions. Use those
+exports if you want to ensure consistent behavior as your code ages.>
+
+Strictly speaking, the year should be specified in a form consistent with
+C<localtime()>, i.e. the offset from 1900. In order to make the interpretation
+of the year easier for humans, however, who are more accustomed to seeing years
+as two-digit or four-digit values, the following conventions are followed:
+
+=over 4
+
+=item *
+
+Years greater than 999 are interpreted as being the actual year, rather than
+the offset from 1900. Thus, 1964 would indicate the year Martin Luther King won
+the Nobel prize, not the year 3864.
+
+=item *
+
+Years in the range 100..999 are interpreted as offset from 1900, so that 112
+indicates 2012. This rule also applies to years less than zero (but see note
+below regarding date range).
+
+=item *
+
+Years in the range 0..99 are interpreted as shorthand for years in the rolling
+"current century," defined as 50 years on either side of the current year.
+Thus, today, in 1999, 0 would refer to 2000, and 45 to 2045, but 55 would refer
+to 1955. Twenty years from now, 55 would instead refer to 2055. This is messy,
+but matches the way people currently think about two digit dates. Whenever
+possible, use an absolute four digit year instead.
+
+=back
+
+The scheme above allows interpretation of a wide range of dates, particularly
+if 4-digit years are used. But it also means that the behavior of your code
+changes as time passes, because the rolling "current century" changes each
+year.
+
+=head2 Limits of time_t
+
+On perl versions older than 5.12.0, the range of dates that can be actually be
+handled depends on the size of C<time_t> (usually a signed integer) on the
+given platform. Currently, this is 32 bits for most systems, yielding an
+approximate range from Dec 1901 to Jan 2038.
+
+Both C<timelocal()> and C<timegm()> croak if given dates outside the supported
+range.
+
+As of version 5.12.0, perl has stopped using the time implementation of the
+operating system it's running on. Instead, it has its own implementation of
+those routines with a safe range of at least +/- 2**52 (about 142 million
+years)
+
+=head2 Ambiguous Local Times (DST)
+
+Because of DST changes, there are many time zones where the same local time
+occurs for two different GMT times on the same day. For example, in the
+"Europe/Paris" time zone, the local time of 2001-10-28 02:30:00 can represent
+either 2001-10-28 00:30:00 GMT, B<or> 2001-10-28 01:30:00 GMT.
+
+When given an ambiguous local time, the timelocal() function will always return
+the epoch for the I<earlier> of the two possible GMT times.
+
+=head2 Non-Existent Local Times (DST)
+
+When a DST change causes a locale clock to skip one hour forward, there will be
+an hour's worth of local times that don't exist. Again, for the "Europe/Paris"
+time zone, the local clock jumped from 2001-03-25 01:59:59 to 2001-03-25
+03:00:00.
+
+If the C<timelocal()> function is given a non-existent local time, it will
+simply return an epoch value for the time one hour later.
+
+=head2 Negative Epoch Values
+
+On perl version 5.12.0 and newer, negative epoch values are fully supported.
+
+On older versions of perl, negative epoch (C<time_t>) values, which are not
+officially supported by the POSIX standards, are known not to work on some
+systems. These include MacOS (pre-OSX) and Win32.
+
+On systems which do support negative epoch values, this module should be able
+to cope with dates before the start of the epoch, down the minimum value of
+time_t for the system.
+
+=head1 IMPLEMENTATION
+
+These routines are quite efficient and yet are always guaranteed to agree with
+C<localtime()> and C<gmtime()>. We manage this by caching the start times of
+any months we've seen before. If we know the start time of the month, we can
+always calculate any time within the month.  The start times are calculated
+using a mathematical formula. Unlike other algorithms that do multiple calls to
+C<gmtime()>.
+
+The C<timelocal()> function is implemented using the same cache. We just assume
+that we're translating a GMT time, and then fudge it when we're done for the
+timezone and daylight savings arguments. Note that the timezone is evaluated
+for each date because countries occasionally change their official timezones.
+Assuming that C<localtime()> corrects for these changes, this routine will also
+be correct.
+
+=head1 AUTHORS EMERITUS
+
+This module is based on a Perl 4 library, timelocal.pl, that was included with
+Perl 4.036, and was most likely written by Tom Christiansen.
+
+The current version was written by Graham Barr.
+
+=head1 BUGS
+
+The whole scheme for interpreting two-digit years can be considered a bug.
+
+Bugs may be submitted at L<https://github.com/houseabsolute/Time-Local/issues>.
+
+There is a mailing list available for users of this distribution,
+L<mailto:datetime@perl.org>.
+
+=head1 SOURCE
+
+The source code repository for Time-Local can be found at L<https://github.com/houseabsolute/Time-Local>.
+
+=head1 AUTHOR
+
+Dave Rolsky <autarch@urth.org>
+
+=head1 CONTRIBUTORS
+
+=for stopwords Florian Ragwitz Gregory Oschwald J. Nick Koston Tom Wyant Unknown
+
+=over 4
+
+=item *
+
+Florian Ragwitz <rafl@debian.org>
+
+=item *
+
+Gregory Oschwald <oschwald@gmail.com>
+
+=item *
+
+J. Nick Koston <nick@cpanel.net>
+
+=item *
+
+Tom Wyant <wyant@cpan.org>
+
+=item *
+
+Unknown <unknown@example.com>
+
+=back
+
+=head1 COPYRIGHT AND LICENSE
+
+This software is copyright (c) 1997 - 2023 by Graham Barr & Dave Rolsky.
+
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+
+The full text of the license can be found in the
+F<LICENSE> file included with this distribution.
+
+=cut

git/usr/share/perl5/core_perl/Time/gmtime.pm

@@ -0,0 +1,88 @@
+package Time::gmtime 1.05;
+use v5.38;
+
+use parent 'Time::tm';
+
+our (   $tm_sec, $tm_min, $tm_hour, $tm_mday,
+        $tm_mon, $tm_year, $tm_wday, $tm_yday, 
+		$tm_isdst,
+);
+
+use Exporter 'import';
+our @EXPORT      = qw(gmtime gmctime);
+our @EXPORT_OK   = qw(
+			$tm_sec $tm_min $tm_hour $tm_mday 
+			$tm_mon $tm_year $tm_wday $tm_yday 
+			$tm_isdst
+		    );
+our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] );
+
+sub populate {
+    return unless @_;
+    my $tmob = Time::tm->new();
+    @$tmob = (
+		$tm_sec, $tm_min, $tm_hour, $tm_mday, 
+		$tm_mon, $tm_year, $tm_wday, $tm_yday, 
+		$tm_isdst )
+	    = @_;
+    return $tmob;
+} 
+
+sub gmtime  :prototype(;$) { populate CORE::gmtime(@_ ? shift : time) }
+sub gmctime :prototype(;$) { scalar   CORE::gmtime(@_ ? shift : time) }
+
+__END__
+
+=head1 NAME
+
+Time::gmtime - by-name interface to Perl's built-in gmtime() function
+
+=head1 SYNOPSIS
+
+ use Time::gmtime;
+ $gm = gmtime();
+ printf "The day in Greenwich is %s\n", 
+    (qw(Sun Mon Tue Wed Thu Fri Sat Sun))[ $gm->wday() ];
+
+ use Time::gmtime qw(:FIELDS);
+ gmtime();
+ printf "The day in Greenwich is %s\n", 
+    (qw(Sun Mon Tue Wed Thu Fri Sat Sun))[ $tm_wday ];
+
+ $now = gmctime();
+
+ use Time::gmtime;
+ use File::stat;
+ $date_string = gmctime(stat($file)->mtime);
+
+=head1 DESCRIPTION
+
+This module's default exports override the core gmtime() function,
+replacing it with a version that returns "Time::tm" objects.
+This object has methods that return the similarly named structure field
+name from the C's tm structure from F<time.h>; namely sec, min, hour,
+mday, mon, year, wday, yday, and isdst.
+
+You may also import all the structure fields directly into your namespace
+as regular variables using the :FIELDS import tag.  (Note that this
+still overrides your core functions.)  Access these fields as variables
+named with a preceding C<tm_> in front their method names.  Thus,
+C<$tm_obj-E<gt>mday()> corresponds to $tm_mday if you import the fields.
+
+The gmctime() function provides a way of getting at the 
+scalar sense of the original CORE::gmtime() function.
+
+To access this functionality without the core overrides,
+pass the C<use> an empty import list, and then access
+function functions with their full qualified names.
+On the other hand, the built-ins are still available
+via the C<CORE::> pseudo-package.
+
+=head1 NOTE
+
+While this class is currently implemented using the Class::Struct
+module to build a struct-like class, you shouldn't rely upon this.
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/Time/localtime.pm

@@ -0,0 +1,83 @@
+package Time::localtime 1.04;
+use v5.38;
+
+use parent 'Time::tm';
+
+our (  
+      $tm_sec, $tm_min, $tm_hour, $tm_mday,
+      $tm_mon, $tm_year, $tm_wday, $tm_yday,
+      $tm_isdst
+);
+
+use Exporter   'import';
+our @EXPORT      = qw(localtime ctime);
+our @EXPORT_OK   = qw(
+			$tm_sec $tm_min $tm_hour $tm_mday 
+			$tm_mon $tm_year $tm_wday $tm_yday 
+			$tm_isdst
+		    );
+our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] );
+
+sub populate {
+    return unless @_;
+    my $tmob = Time::tm->new();
+    @$tmob = (
+		$tm_sec, $tm_min, $tm_hour, $tm_mday, 
+		$tm_mon, $tm_year, $tm_wday, $tm_yday, 
+		$tm_isdst )
+	    = @_;
+    return $tmob;
+} 
+
+sub localtime :prototype(;$) { populate CORE::localtime(@_ ? shift : time) }
+sub ctime     :prototype(;$) { scalar   CORE::localtime(@_ ? shift : time) }
+
+__END__
+
+=head1 NAME
+
+Time::localtime - by-name interface to Perl's built-in localtime() function
+
+=head1 SYNOPSIS
+
+ use Time::localtime;
+ printf "Year is %d\n", localtime->year() + 1900;
+
+ $now = ctime();
+
+ use Time::localtime;
+ use File::stat;
+ $date_string = ctime(stat($file)->mtime);
+
+=head1 DESCRIPTION
+
+This module's default exports override the core localtime() function,
+replacing it with a version that returns "Time::tm" objects.
+This object has methods that return the similarly named structure field
+name from the C's tm structure from F<time.h>; namely sec, min, hour,
+mday, mon, year, wday, yday, and isdst.
+
+You may also import all the structure fields directly into your namespace
+as regular variables using the :FIELDS import tag.  (Note that this still
+overrides your core functions.)  Access these fields as
+variables named with a preceding C<tm_> in front their method names.
+Thus, C<$tm_obj-E<gt>mday()> corresponds to $tm_mday if you import
+the fields.
+
+The ctime() function provides a way of getting at the 
+scalar sense of the original CORE::localtime() function.
+
+To access this functionality without the core overrides,
+pass the C<use> an empty import list, and then access
+function functions with their full qualified names.
+On the other hand, the built-ins are still available
+via the C<CORE::> pseudo-package.
+
+=head1 NOTE
+
+While this class is currently implemented using the Class::Struct
+module to build a struct-like class, you shouldn't rely upon this.
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/Time/tm.pm

@@ -0,0 +1,30 @@
+package Time::tm 1.01;
+use v5.38;
+
+use Class::Struct qw(struct);
+struct('Time::tm' => [
+     map { $_ => '$' } qw{ sec min hour mday mon year wday yday isdst }
+]);
+
+__END__
+
+=head1 NAME
+
+Time::tm - internal object used by Time::gmtime and Time::localtime
+
+=head1 SYNOPSIS
+
+Don't use this module directly.
+
+=head1 DESCRIPTION
+
+This module is used internally as a base class by Time::localtime And
+Time::gmtime functions.  It creates a Time::tm struct object which is
+addressable just like's C's tm structure from F<time.h>; namely with sec,
+min, hour, mday, mon, year, wday, yday, and isdst.
+
+This class is an internal interface only. 
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/unicore/Blocks.txt

@@ -0,0 +1,375 @@
+# Blocks-16.0.0.txt
+# Date: 2024-02-02
+# © 2024 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+# For documentation, see https://www.unicode.org/reports/tr44/
+#
+# Format:
+# Start Code..End Code; Block Name
+
+# ================================================
+
+# Note:   When comparing block names, casing, whitespace, hyphens,
+#         and underbars are ignored.
+#         For example, "Latin Extended-A" and "latin extended a" are equivalent.
+#         For more information on the comparison of property values,
+#            see UAX #44: https://www.unicode.org/reports/tr44/
+#
+#  All block ranges start with a value where (cp MOD 16) = 0,
+#  and end with a value where (cp MOD 16) = 15. In other words,
+#  the last hexadecimal digit of the start of range is ...0
+#  and the last hexadecimal digit of the end of range is ...F.
+#  This constraint on block ranges guarantees that allocations
+#  are done in terms of whole columns, and that code chart display
+#  never involves splitting columns in the charts.
+#
+#  All code points not explicitly listed for Block
+#  have the value No_Block.
+
+# Property:	Block
+#
+# @missing: 0000..10FFFF; No_Block
+
+0000..007F; Basic Latin
+0080..00FF; Latin-1 Supplement
+0100..017F; Latin Extended-A
+0180..024F; Latin Extended-B
+0250..02AF; IPA Extensions
+02B0..02FF; Spacing Modifier Letters
+0300..036F; Combining Diacritical Marks
+0370..03FF; Greek and Coptic
+0400..04FF; Cyrillic
+0500..052F; Cyrillic Supplement
+0530..058F; Armenian
+0590..05FF; Hebrew
+0600..06FF; Arabic
+0700..074F; Syriac
+0750..077F; Arabic Supplement
+0780..07BF; Thaana
+07C0..07FF; NKo
+0800..083F; Samaritan
+0840..085F; Mandaic
+0860..086F; Syriac Supplement
+0870..089F; Arabic Extended-B
+08A0..08FF; Arabic Extended-A
+0900..097F; Devanagari
+0980..09FF; Bengali
+0A00..0A7F; Gurmukhi
+0A80..0AFF; Gujarati
+0B00..0B7F; Oriya
+0B80..0BFF; Tamil
+0C00..0C7F; Telugu
+0C80..0CFF; Kannada
+0D00..0D7F; Malayalam
+0D80..0DFF; Sinhala
+0E00..0E7F; Thai
+0E80..0EFF; Lao
+0F00..0FFF; Tibetan
+1000..109F; Myanmar
+10A0..10FF; Georgian
+1100..11FF; Hangul Jamo
+1200..137F; Ethiopic
+1380..139F; Ethiopic Supplement
+13A0..13FF; Cherokee
+1400..167F; Unified Canadian Aboriginal Syllabics
+1680..169F; Ogham
+16A0..16FF; Runic
+1700..171F; Tagalog
+1720..173F; Hanunoo
+1740..175F; Buhid
+1760..177F; Tagbanwa
+1780..17FF; Khmer
+1800..18AF; Mongolian
+18B0..18FF; Unified Canadian Aboriginal Syllabics Extended
+1900..194F; Limbu
+1950..197F; Tai Le
+1980..19DF; New Tai Lue
+19E0..19FF; Khmer Symbols
+1A00..1A1F; Buginese
+1A20..1AAF; Tai Tham
+1AB0..1AFF; Combining Diacritical Marks Extended
+1B00..1B7F; Balinese
+1B80..1BBF; Sundanese
+1BC0..1BFF; Batak
+1C00..1C4F; Lepcha
+1C50..1C7F; Ol Chiki
+1C80..1C8F; Cyrillic Extended-C
+1C90..1CBF; Georgian Extended
+1CC0..1CCF; Sundanese Supplement
+1CD0..1CFF; Vedic Extensions
+1D00..1D7F; Phonetic Extensions
+1D80..1DBF; Phonetic Extensions Supplement
+1DC0..1DFF; Combining Diacritical Marks Supplement
+1E00..1EFF; Latin Extended Additional
+1F00..1FFF; Greek Extended
+2000..206F; General Punctuation
+2070..209F; Superscripts and Subscripts
+20A0..20CF; Currency Symbols
+20D0..20FF; Combining Diacritical Marks for Symbols
+2100..214F; Letterlike Symbols
+2150..218F; Number Forms
+2190..21FF; Arrows
+2200..22FF; Mathematical Operators
+2300..23FF; Miscellaneous Technical
+2400..243F; Control Pictures
+2440..245F; Optical Character Recognition
+2460..24FF; Enclosed Alphanumerics
+2500..257F; Box Drawing
+2580..259F; Block Elements
+25A0..25FF; Geometric Shapes
+2600..26FF; Miscellaneous Symbols
+2700..27BF; Dingbats
+27C0..27EF; Miscellaneous Mathematical Symbols-A
+27F0..27FF; Supplemental Arrows-A
+2800..28FF; Braille Patterns
+2900..297F; Supplemental Arrows-B
+2980..29FF; Miscellaneous Mathematical Symbols-B
+2A00..2AFF; Supplemental Mathematical Operators
+2B00..2BFF; Miscellaneous Symbols and Arrows
+2C00..2C5F; Glagolitic
+2C60..2C7F; Latin Extended-C
+2C80..2CFF; Coptic
+2D00..2D2F; Georgian Supplement
+2D30..2D7F; Tifinagh
+2D80..2DDF; Ethiopic Extended
+2DE0..2DFF; Cyrillic Extended-A
+2E00..2E7F; Supplemental Punctuation
+2E80..2EFF; CJK Radicals Supplement
+2F00..2FDF; Kangxi Radicals
+2FF0..2FFF; Ideographic Description Characters
+3000..303F; CJK Symbols and Punctuation
+3040..309F; Hiragana
+30A0..30FF; Katakana
+3100..312F; Bopomofo
+3130..318F; Hangul Compatibility Jamo
+3190..319F; Kanbun
+31A0..31BF; Bopomofo Extended
+31C0..31EF; CJK Strokes
+31F0..31FF; Katakana Phonetic Extensions
+3200..32FF; Enclosed CJK Letters and Months
+3300..33FF; CJK Compatibility
+3400..4DBF; CJK Unified Ideographs Extension A
+4DC0..4DFF; Yijing Hexagram Symbols
+4E00..9FFF; CJK Unified Ideographs
+A000..A48F; Yi Syllables
+A490..A4CF; Yi Radicals
+A4D0..A4FF; Lisu
+A500..A63F; Vai
+A640..A69F; Cyrillic Extended-B
+A6A0..A6FF; Bamum
+A700..A71F; Modifier Tone Letters
+A720..A7FF; Latin Extended-D
+A800..A82F; Syloti Nagri
+A830..A83F; Common Indic Number Forms
+A840..A87F; Phags-pa
+A880..A8DF; Saurashtra
+A8E0..A8FF; Devanagari Extended
+A900..A92F; Kayah Li
+A930..A95F; Rejang
+A960..A97F; Hangul Jamo Extended-A
+A980..A9DF; Javanese
+A9E0..A9FF; Myanmar Extended-B
+AA00..AA5F; Cham
+AA60..AA7F; Myanmar Extended-A
+AA80..AADF; Tai Viet
+AAE0..AAFF; Meetei Mayek Extensions
+AB00..AB2F; Ethiopic Extended-A
+AB30..AB6F; Latin Extended-E
+AB70..ABBF; Cherokee Supplement
+ABC0..ABFF; Meetei Mayek
+AC00..D7AF; Hangul Syllables
+D7B0..D7FF; Hangul Jamo Extended-B
+D800..DB7F; High Surrogates
+DB80..DBFF; High Private Use Surrogates
+DC00..DFFF; Low Surrogates
+E000..F8FF; Private Use Area
+F900..FAFF; CJK Compatibility Ideographs
+FB00..FB4F; Alphabetic Presentation Forms
+FB50..FDFF; Arabic Presentation Forms-A
+FE00..FE0F; Variation Selectors
+FE10..FE1F; Vertical Forms
+FE20..FE2F; Combining Half Marks
+FE30..FE4F; CJK Compatibility Forms
+FE50..FE6F; Small Form Variants
+FE70..FEFF; Arabic Presentation Forms-B
+FF00..FFEF; Halfwidth and Fullwidth Forms
+FFF0..FFFF; Specials
+10000..1007F; Linear B Syllabary
+10080..100FF; Linear B Ideograms
+10100..1013F; Aegean Numbers
+10140..1018F; Ancient Greek Numbers
+10190..101CF; Ancient Symbols
+101D0..101FF; Phaistos Disc
+10280..1029F; Lycian
+102A0..102DF; Carian
+102E0..102FF; Coptic Epact Numbers
+10300..1032F; Old Italic
+10330..1034F; Gothic
+10350..1037F; Old Permic
+10380..1039F; Ugaritic
+103A0..103DF; Old Persian
+10400..1044F; Deseret
+10450..1047F; Shavian
+10480..104AF; Osmanya
+104B0..104FF; Osage
+10500..1052F; Elbasan
+10530..1056F; Caucasian Albanian
+10570..105BF; Vithkuqi
+105C0..105FF; Todhri
+10600..1077F; Linear A
+10780..107BF; Latin Extended-F
+10800..1083F; Cypriot Syllabary
+10840..1085F; Imperial Aramaic
+10860..1087F; Palmyrene
+10880..108AF; Nabataean
+108E0..108FF; Hatran
+10900..1091F; Phoenician
+10920..1093F; Lydian
+10980..1099F; Meroitic Hieroglyphs
+109A0..109FF; Meroitic Cursive
+10A00..10A5F; Kharoshthi
+10A60..10A7F; Old South Arabian
+10A80..10A9F; Old North Arabian
+10AC0..10AFF; Manichaean
+10B00..10B3F; Avestan
+10B40..10B5F; Inscriptional Parthian
+10B60..10B7F; Inscriptional Pahlavi
+10B80..10BAF; Psalter Pahlavi
+10C00..10C4F; Old Turkic
+10C80..10CFF; Old Hungarian
+10D00..10D3F; Hanifi Rohingya
+10D40..10D8F; Garay
+10E60..10E7F; Rumi Numeral Symbols
+10E80..10EBF; Yezidi
+10EC0..10EFF; Arabic Extended-C
+10F00..10F2F; Old Sogdian
+10F30..10F6F; Sogdian
+10F70..10FAF; Old Uyghur
+10FB0..10FDF; Chorasmian
+10FE0..10FFF; Elymaic
+11000..1107F; Brahmi
+11080..110CF; Kaithi
+110D0..110FF; Sora Sompeng
+11100..1114F; Chakma
+11150..1117F; Mahajani
+11180..111DF; Sharada
+111E0..111FF; Sinhala Archaic Numbers
+11200..1124F; Khojki
+11280..112AF; Multani
+112B0..112FF; Khudawadi
+11300..1137F; Grantha
+11380..113FF; Tulu-Tigalari
+11400..1147F; Newa
+11480..114DF; Tirhuta
+11580..115FF; Siddham
+11600..1165F; Modi
+11660..1167F; Mongolian Supplement
+11680..116CF; Takri
+116D0..116FF; Myanmar Extended-C
+11700..1174F; Ahom
+11800..1184F; Dogra
+118A0..118FF; Warang Citi
+11900..1195F; Dives Akuru
+119A0..119FF; Nandinagari
+11A00..11A4F; Zanabazar Square
+11A50..11AAF; Soyombo
+11AB0..11ABF; Unified Canadian Aboriginal Syllabics Extended-A
+11AC0..11AFF; Pau Cin Hau
+11B00..11B5F; Devanagari Extended-A
+11BC0..11BFF; Sunuwar
+11C00..11C6F; Bhaiksuki
+11C70..11CBF; Marchen
+11D00..11D5F; Masaram Gondi
+11D60..11DAF; Gunjala Gondi
+11EE0..11EFF; Makasar
+11F00..11F5F; Kawi
+11FB0..11FBF; Lisu Supplement
+11FC0..11FFF; Tamil Supplement
+12000..123FF; Cuneiform
+12400..1247F; Cuneiform Numbers and Punctuation
+12480..1254F; Early Dynastic Cuneiform
+12F90..12FFF; Cypro-Minoan
+13000..1342F; Egyptian Hieroglyphs
+13430..1345F; Egyptian Hieroglyph Format Controls
+13460..143FF; Egyptian Hieroglyphs Extended-A
+14400..1467F; Anatolian Hieroglyphs
+16100..1613F; Gurung Khema
+16800..16A3F; Bamum Supplement
+16A40..16A6F; Mro
+16A70..16ACF; Tangsa
+16AD0..16AFF; Bassa Vah
+16B00..16B8F; Pahawh Hmong
+16D40..16D7F; Kirat Rai
+16E40..16E9F; Medefaidrin
+16F00..16F9F; Miao
+16FE0..16FFF; Ideographic Symbols and Punctuation
+17000..187FF; Tangut
+18800..18AFF; Tangut Components
+18B00..18CFF; Khitan Small Script
+18D00..18D7F; Tangut Supplement
+1AFF0..1AFFF; Kana Extended-B
+1B000..1B0FF; Kana Supplement
+1B100..1B12F; Kana Extended-A
+1B130..1B16F; Small Kana Extension
+1B170..1B2FF; Nushu
+1BC00..1BC9F; Duployan
+1BCA0..1BCAF; Shorthand Format Controls
+1CC00..1CEBF; Symbols for Legacy Computing Supplement
+1CF00..1CFCF; Znamenny Musical Notation
+1D000..1D0FF; Byzantine Musical Symbols
+1D100..1D1FF; Musical Symbols
+1D200..1D24F; Ancient Greek Musical Notation
+1D2C0..1D2DF; Kaktovik Numerals
+1D2E0..1D2FF; Mayan Numerals
+1D300..1D35F; Tai Xuan Jing Symbols
+1D360..1D37F; Counting Rod Numerals
+1D400..1D7FF; Mathematical Alphanumeric Symbols
+1D800..1DAAF; Sutton SignWriting
+1DF00..1DFFF; Latin Extended-G
+1E000..1E02F; Glagolitic Supplement
+1E030..1E08F; Cyrillic Extended-D
+1E100..1E14F; Nyiakeng Puachue Hmong
+1E290..1E2BF; Toto
+1E2C0..1E2FF; Wancho
+1E4D0..1E4FF; Nag Mundari
+1E5D0..1E5FF; Ol Onal
+1E7E0..1E7FF; Ethiopic Extended-B
+1E800..1E8DF; Mende Kikakui
+1E900..1E95F; Adlam
+1EC70..1ECBF; Indic Siyaq Numbers
+1ED00..1ED4F; Ottoman Siyaq Numbers
+1EE00..1EEFF; Arabic Mathematical Alphabetic Symbols
+1F000..1F02F; Mahjong Tiles
+1F030..1F09F; Domino Tiles
+1F0A0..1F0FF; Playing Cards
+1F100..1F1FF; Enclosed Alphanumeric Supplement
+1F200..1F2FF; Enclosed Ideographic Supplement
+1F300..1F5FF; Miscellaneous Symbols and Pictographs
+1F600..1F64F; Emoticons
+1F650..1F67F; Ornamental Dingbats
+1F680..1F6FF; Transport and Map Symbols
+1F700..1F77F; Alchemical Symbols
+1F780..1F7FF; Geometric Shapes Extended
+1F800..1F8FF; Supplemental Arrows-C
+1F900..1F9FF; Supplemental Symbols and Pictographs
+1FA00..1FA6F; Chess Symbols
+1FA70..1FAFF; Symbols and Pictographs Extended-A
+1FB00..1FBFF; Symbols for Legacy Computing
+20000..2A6DF; CJK Unified Ideographs Extension B
+2A700..2B73F; CJK Unified Ideographs Extension C
+2B740..2B81F; CJK Unified Ideographs Extension D
+2B820..2CEAF; CJK Unified Ideographs Extension E
+2CEB0..2EBEF; CJK Unified Ideographs Extension F
+2EBF0..2EE5F; CJK Unified Ideographs Extension I
+2F800..2FA1F; CJK Compatibility Ideographs Supplement
+30000..3134F; CJK Unified Ideographs Extension G
+31350..323AF; CJK Unified Ideographs Extension H
+E0000..E007F; Tags
+E0100..E01EF; Variation Selectors Supplement
+F0000..FFFFF; Supplementary Private Use Area-A
+100000..10FFFF; Supplementary Private Use Area-B
+
+# EOF