📄 libtempfile-9a6775f13b1e495d.rmeta
/home/palash/git/iron_learn/target/debug/deps/libtempfile-9a6775f13b1e495d.rmeta
Language: rmeta • Lines: 2825
rust
!�#rustc 1.92.0 (ded5c06cf 2025-12-08)���	ⷄ�ۆ��p��-225863f279df55c4��١�	�T�6a��D�
-5080178c80bf7a93��uӰ]����d��!�-06039bcfba61f665��**�٭T��HО�9�-3e2e950d4bac10b5��	�t�#3Ҵη��Ǣ-d25e598578fbf080�rustc_std_workspace_core������Nm��gmY���-327ea4f353b4eb8c���y.:i���gy"1�r-94fdfaf0af91a65d�miniz_oxide�M�^�yTLm�L�d=B-5312b588e5cfab93�adler2��;~�7�ɴ,P?���-1e0b0d62df36c85c�	hashbrown�L�ϫ	2݆y��q-2ed6a8f06fc51a9d�rustc_std_workspace_alloc�a���p��H����6Z�-05b02707a5b2a256�
std_detect�	c�LN����=1�ʶӐ-5978f0713dd5442d�rustc_demangle�X�Fq��UՃ�>7z
��-43b2ff22c18e1125�cfg_if�֦<����ɐ¬�-6a40188dd7d989d2�	addr2line���,2�!xb�"6�!�	-11d54e777384a9e5�gimli��2��I.�ġ�����-35018e994bad7042�object��T �f��Y�
hQec-2dc10b344e05b569�memchr��xZT9�C��I�Mg�-09f2ab7e0d97e07a��~ݤ	����h���-932f22f820d1e5ec�rustix����SKF�4iIm-801640df58904263�
linux_raw_sys�q�F�4�.��x���_H�-ed34a42c920f706f�bitflags����w[����8���]-b3a8eec3e14046b1�	once_cell����q�N�ŧrq��s��-5e658f453c242ca5�fastrand���~��1��(��OJ-eae3323db88dd8c3�	getrandom��S�Le���.hA~�-1dc0a0d0c3ca7f7a���v�
їG}�/x$YxD-e720413b8edafa0a��	+Y�D]�O.ʼ��
$�-965a3d5e7b2182f0�����9�L�$@4?[AsFd�$��L�wasi�4���[AsRawFd�<��)�#!#[
BorrowedFd�T��K�ECE[RawFd�,��h�b`b[AsHandle�D��<�[AsRawHandle�\�� #%[BorrowedHandle�t��ADF[	RawHandle�L��]`bwcreate�4��L�linux�<������
tempdir_in�TG�5�tempfile_in�\S�"$�Builder�<`�9<>�NUM_RETRIES�NUM_RAND_CHARS�dir�	
tempdir��
P�TempDir��disable_cleanup��
new_in� �with_prefix�"S�with_suffix�$�with_suffix_in�&�&�with_prefix_in�)�)��	into_path�keep��close�0	2�4�6��imp�9�:::::�????	?	9error�FFFFFFL�FNsource�FIoResultExt�P�P
with_err_path�RF�R�FU�U�W�W�W	�[[[[[[[[[[	[
[[[
[[[[[[[[[[[[[�vplatform�wwwwwwwwww	w
wwwcreate_named�����	wcreate_unlinked�w������	wcreate_unix��	wreopen�wpersist����������NOSYS�w�v[tempfile�[�
��[��[��[��[��[TempPath�����[���	�����persist_noclobber��������	from_path��impl Into<PathBuf>��
try_from_path�����
[��[��[����[��[	��[
NamedTempFile�������[
����[����[PersistError�������[����[
����[����[����[����[��
������������������������[�������������������as_file��as_file_mut��	into_file��into_temp_path��
into_parts��
from_parts�[���	[���read��	�
read_vectored��	�read_to_end��	�read_to_string��	�
read_exact��	[���	���	���	���	���	[���write��	�flush��	�write_vectored��	�	write_all��	���	[���	���	���	���	���	[���seek��	[�� �	[���as_fd�[���	as_raw_fd�[��	�	spooled�����������	�
���spooled_tempfile��spooled_tempfile_in����cursor_to_tempfile����
�����	is_rolled��roll��set_len��
into_inner������������������������ util�����������	�tmpname���	�
create_helper��R��$impl FnMut(PathBuf) -> io::Result<R>��	�������DEFAULT_TEMPDIR��override_temp_dir��	�temp_dir��		

�>�'a��'b���
�prefix����suffix����
rand_bytes��append��permissions���������
���	����
���	�make�����$�make_in�����$���	F	PathError����err�F��[PathPersistError�����[���SpooledData��InMemory��
���OnDisk��
������SpooledTempFile��max_size����inner�����	�
��&��&�
random_len���&��&��'��'����&��&����&��&����&��&����&��&��&��&��,8/8385858587888?8M8M8M8O8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8P�����h��N���-�-��-�*�+{��Gs;*"�_�6��6�_���(��F��(FQPSP�Z��_�7��7P��������������������q�aX������
�"�f+�c�8�_���(����2vL�;�����8�9������[��[t�6y��9�_�9��9�_�9��9��9��9�6��9�����*�Jp/K�\�_�����[��[N�+�@=����;�6�_��������{�
g�OE�;��8�;��;�;�_�;��;��;�8�����[��[N�+�@=������*�.��g�<���;��<��;��<�)�;�)�;�_����)�����)���u�6-1���_���)��*������*�C�0��R���>��>��>�_���
��*��&��&��'��'��Gh�@�h��&�&��?��?���?��?�?����
��*��&��&��'��'��Gh�@�h�882������4����������������6��L�����N�����U���������������
�����
�����
�������������������_	�=�_�P������)�)������,�A
��A�D�A$65536��A
��A �E,�A$6��
�E�,�E7>4�D�
��%�=0�G�GCursor��G�*��Gpos��y.)I�B�?�?�?��?buf��:�?�	�:$x��Lk��B�B�BGlobal�����I����4�
��%�=0�=7>F[������,�A�OpenOptions�\�B�GPermissions�\�B�Gio��B�	�$�B�-
�<�C��
T�C��<�C��D�C���
\�C���l�C���(��D���d�D���D�D���!��D���!��D���)\�D���)|�E������a^ This is a library for creating temporary files and directories that are automatically deleted��b.+ when no longer referenced (i.e., on drop).�����]Z - Use [`tempfile()`] when you need a real [`std::fs::File`] but don't need to refer to it�t�   by-path.���eb - Use [`NamedTempFile::new()`] when you need a _named_ temporary file that can be referred to its�\�   path.���eb - Use [`tempdir()`] when you need a temporary directory that will be recursively deleted on drop.���da - Use [`spooled_tempfile()`] when you need an in-memory buffer that will ultimately be backed by���,)   a temporary file if it gets too large.���d�	 # Design�����WT This crate provides several approaches to creating temporary files and directories.���`] [`tempfile()`] relies on the OS to remove the temporary file once the last handle is closed.���PM [`TempDir`] and [`NamedTempFile`] both rely on Rust destructors for cleanup.����� ## Resource Leaking�����]Z `tempfile` will (almost) never fail to cleanup temporary resources. However `TempDir` and���b_ `NamedTempFile` will fail if their destructors don't run. This is because `tempfile` relies on���[X the OS to cleanup the underlying file, while `TempDir` and `NamedTempFile` rely on rust���	_\ destructors to do so. Destructors may fail to run if the process exits through an unhandled���
ZW signal interrupt (like `SIGINT`), or if the instance is declared statically (like with���30 [`lazy_static`]), among other possible reasons.����� ## Unexpected File Deletion�����da Most operating systems periodically clean up temporary files that haven't been accessed recently���a^ (often on the order of multiple days). This issue does not affect unnamed temporary files but���
c` can invalidate the paths associated with named temporary files on Unix-like systems because the���[X temporary file can be unlinked from the filesystem while still open and in-use. See the���^[ [temporary file cleaner](#temporary-file-cleaners) section for more security implications.���|� ## Security�����b_ This section discusses security issues relevant to Unix-like operating systems that use shared���a^ temporary directories by default. Importantly, it's not relevant for Windows or macOS as both���LI operating systems use private per-user temporary directories by default.�����_\ Applications can mitigate the issues described below by using [`env::override_temp_dir`] to���`] change the default temporary directory but should do so if and only if default the temporary���`] directory ([`env::temp_dir`]) is unsuitable (is world readable, world writable, managed by a���" temporary file cleaner, etc.).����� ### Temporary File Cleaners�����c` In the presence of pathological temporary file cleaner, relying on file paths is unsafe because���b_ a temporary file cleaner could delete the temporary file which an attacker could then replace.�����eb This isn't an issue for [`tempfile`] as it doesn't rely on file paths. However, [`NamedTempFile`]���]Z and temporary directories _do_ rely on file paths for _some_ operations. See the security���ZW documentation on the [`NamedTempFile`] and the [`TempDir`] types for more information.���|� Mitigation:�����b_ - This is rarely an issue for short-lived files as temporary file cleaners usually only remove���VS   temporary files that haven't been modified or accessed within many (10-30) days.���c` - Very long lived temporary files should be placed in directories not managed by temporary file�|�   cleaners.���Ԕ ### Access Permissions�����`] Temporary _files_ created with this library are private by default on all operating systems.���c` However, temporary _directories_ are created with the default permissions and will therefore be���^[ world-readable by default unless the user has changed their umask and/or default temporary�t� directory.����� ### Denial of Service�����a^ If the file-name randomness ([`Builder::rand_bytes`]) is too small and/or this crate is built���b_ without the `getrandom` feature, it may be possible for an attacker to predict the random file���`] names chosen by this library, preventing temporary file creation by creating temporary files��� ^[ with these predicted file names. By default, this library mitigates this denial of service�t�! attack by:��!���!b_ 1. Defaulting to 6 random characters per temporary file forcing an attacker to create billions���"^[    of files before random collisions are expected (at which point you probably have larger���"    problems).���"a^ 2. Re-seeding the random filename generator from system randomness after 3 failed attempts to���#b_    create temporary a file (when the `getrandom` feature is enabled as it is by default on all�Ĺ$    major platforms).��$���$ ## Early drop pitfall��$���$^[ Because `TempDir` and `NamedTempFile` rely on their destructors for cleanup, this can lead���%b_ to an unexpected early removal of the directory/file, usually when working with APIs which are���&?< generic over `AsRef<Path>`. Consider the following example:��&�l�&
 ```no_run�Ԉ' use tempfile::tempdir;���' use std::process::Command;��'���'63 // Create a directory inside of `env::temp_dir()`.���' let temp_dir = tempdir()?;��(���([X // Spawn the `touch` command inside the temporary directory and collect the exit status���(ZW // Note that `temp_dir` is **not** moved into `current_dir`, but passed as a reference���)XU let exit_status = Command::new("touch").arg("tmp").current_dir(&temp_dir).status()?;���*#  assert!(exit_status.success());��*���*" # Ok::<(), std::io::Error>(())�<�* ```��+���+]Z This works because a reference to `temp_dir` is passed to `current_dir`, resulting in the���+]Z destructor of `temp_dir` being run after the `Command` has finished execution. Moving the���,\Y `TempDir` into the `current_dir` call would result in the `TempDir` being converted into���-\Y an internal representation, with the original value being dropped and the directory thus���-63 being deleted, before the command can be executed.��.���.MJ The `touch` command would fail with an `No such file or directory` error.��/�|�/ ## Examples��/���/85 Create a temporary file and write some data into it:��/�<�/�|��/ use tempfile::tempfile;���/ use std::io::Write;��0���01. // Create a file inside of `env::temp_dir()`.���0 let mut file = tempfile()?;��0���00- writeln!(file, "Brian was here. Briefly.")?;���1"�{<�1�|�1���1FC Create a named temporary file and open an independent file handle:��2�<�2�|��2  use tempfile::NamedTempFile;���2 use std::io::{Write, Read};��2���2*' let text = "Brian was here. Briefly.";��3���31����3*' let mut file1 = NamedTempFile::new()?;��3���3 // Re-open it.���4$! let mut file2 = file1.reopen()?;��4���40- // Write some test data to the first handle.���4&# file1.write_all(text.as_bytes())?;��5���52/ // Read the test data using the second handle.���5  let mut buf = String::new();���5$! file2.read_to_string(&mut buf)?;�Ԋ6 assert_eq!(buf, text);���6"�{<�6�|�6���663 Create a temporary directory and add a file to it:��7�<�7�|ԗ7�w��7 use std::fs::File;���7���7���76�x̜8 let dir = tempdir()?;��8���8=: let file_path = dir.path().join("my-temporary-note.txt");���8,) let mut file = File::create(file_path)?;���90���9���9DA // By closing the `TempDir` explicitly, we can check that it has���:B? // been deleted successfully. If we don't close it explicitly,���:>; // the directory will still be deleted when `dir` goes out���;A> // of scope, but we won't know whether deleting the directory���; // succeeded.�|�; drop(file);���< dir.close()?;���<"�{<�<�|�<���<$! [`tempfile()`]: fn.tempfile.html���<" [`tempdir()`]: fn.tempdir.html���=$! [`TempDir`]: struct.TempDir.html���=0- [`NamedTempFile`]: struct.NamedTempFile.html���=RO [`lazy_static`]: https://github.com/rust-lang-nursery/lazy-static.rs/issues/62���>�>�@8�l�>�>7<https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png���>>$�?8���?�?7%https://www.rust-lang.org/favicon.ico���?'$�?8�l�?�?7https://docs.rs/tempfile/latest���?!��>�F[�����
$�$��H8$�G�HV$�G�Hk$�	�~$�-
��$��
�$���$���$���
�$����$���(�$���%���%���!0%���!B%���)T%���)f%��
$
$
$��A\�A�D��At�A�E|�A$��B#8$8$V$V$<�Bk$|�B~$<�B�B89�,��remove_dir_all�t��
mem����$��+�$��-�<��,���*�H���\�P�
<��|�ϼ��D���� �$���|~t�qsbd��Wt�K��'��>; Create a new temporary directory. Also see [`tempdir_in`].�����OL The `tempdir` function creates a directory in the file system and returns a���QN [`TempDir`]. The directory will be automatically deleted when the `TempDir`'s��� destructor is run.����� # Resource Leaking�����C@ See [the resource leaking][resource-leaking] docs on `TempDir`.���t� # Security�����SP Temporary directories are created with the default permissions unless otherwise���UR specified via [`Builder::permissions`]. Depending on your platform, this may make��� them world-readable.���d�	 # Errors�����;8 If the directory can not be created, `Err` is returned.��	�t�	 # Examples��	�<�	�|��	�w��	����
���
���
52 // Create a directory inside of `env::temp_dir()`���
 let tmp_dir = tempdir()?;��
���
A> let file_path = tmp_dir.path().join("my-temporary-note.txt");���0- let mut tmp_file = File::create(file_path)?;���41 writeln!(tmp_file, "Brian was here. Briefly.")?;�����<9 // `tmp_dir` goes out of scope, the directory as well as���'$ // `tmp_file` will be deleted here.���
 drop(tmp_file);���
 tmp_dir.close()?;���
"�{<�
�|�
���
$����<9 [resource-leaking]: struct.TempDir.html#resource-leaking�<���������������������q�aX�6�8
��@��SP Create a new temporary directory in a specific directory. Also see [`tempdir`].�����LI The `tempdir_in` function creates a directory in the specified directory��� and returns a [`TempDir`].���C@ The directory will be automatically deleted when the `TempDir`s���������ݛ����C����d������;����t�џ��<��|�� use tempfile::tempdir_in;�������������:7 // Create a directory inside of the current directory.���#  let tmp_dir = tempdir_in(".")?;�����A����0���4������<���'����٣������"�{<��|����$����<��T��������������6\�
����')��/��DA A directory in the filesystem that is automatically deleted when�̜ it goes out of scope.�����DA The [`TempDir`] type creates a directory on the file system that���>; is deleted once it goes out of scope. At construction, the���EB `TempDir` creates a new directory with a randomly generated name.�����GD The default constructor, [`TempDir::new()`], creates directories in���?< the location returned by [`env::temp_dir()`], but `TempDir`���EB can be configured to manage a temporary directory in any location���'$ by constructing with a [`Builder`].�����B? After creating a `TempDir`, work with the file system by doing���@= standard [`std::fs`] file system operations on its [`Path`],���GD which can be retrieved with [`TempDir::path()`]. Once the `TempDir`���FC value is dropped, the directory at the path will be deleted, along���IF with any files and directories it contains. It is your responsibility���B? to ensure that no further file system operations are attempted��� <9 inside the temporary directory once it has been deleted.�� ��� ݛ� ��� DA Various platform-specific conditions may cause `TempDir` to fail���!EB to delete the underlying directory. It's important to ensure that���"?< handles (like [`File`] and [`ReadDir`]) to files inside the���"EB directory are dropped before the `TempDir` goes out of scope. The���#DA `TempDir` destructor will silently ignore any errors in deleting���#FC the directory; to instead handle errors call [`TempDir::close()`].��$���$EB Note that if the program exits before the `TempDir` destructor is���$DA run, such as via [`std::process::exit()`], by segfaulting, or by���%B? receiving a signal like `SIGINT`, then the temporary directory���% will not be deleted.��&�t�&џ�&���&74 Create a temporary directory with a generated name:��&�<�&�|��&����&��Ԑ' use tempfile::TempDir;��'���'5����'" let tmp_dir = TempDir::new()?;���("�{<�(�|�(���(;8 Create a temporary directory with a prefix in its name:��(�<�(�|��(����)��Ԯ) use tempfile::Builder;��)���)63 // Create a directory inside of `env::temp_dir()`,���*,) // whose name will begin with 'example'.���*>; let tmp_dir = Builder::new().prefix("example").tempdir()?;���*"�{<�+�|�+���+>; [`File`]: http://doc.rust-lang.org/std/fs/struct.File.html���+@= [`Path`]: http://doc.rust-lang.org/std/path/struct.Path.html���,DA [`ReadDir`]: http://doc.rust-lang.org/std/fs/struct.ReadDir.html���,$! [`Builder`]: struct.Builder.html���-:7 [`TempDir::close()`]: struct.TempDir.html#method.close���-63 [`TempDir::new()`]: struct.TempDir.html#method.new���-85 [`TempDir::path()`]: struct.TempDir.html#method.path���.$����.;8 [`std::fs`]: http://doc.rust-lang.org/std/fs/index.html���/OL [`std::process::exit()`]: http://doc.rust-lang.org/std/process/fn.exit.html�<�/�6�h��N��7|�/$�/���Box�������lf���]v�6�G��0|�0d�0�6 "$&),-./0��8#��0GD Attempts to make a temporary directory inside of `env::temp_dir()`.��1���1+( See [`Builder`] for more configuration.��1���1HE The directory and everything inside it will be automatically deleted���2-* once the returned `TempDir` is destroyed.��2�d�2��2���2;���3�t�3џ�3�<�3�|��3����3��Ԓ4ս�4���45����4"���5���5A����50���64���6���6<���7'����7"�{<�7�|�7���8$���8��
��?<��9;8 Attempts to make a temporary directory inside of `dir`.���9@= The directory and everything inside it will be automatically���:52 deleted once the returned `TempDir` is destroyed.��:�d�:��:���:;���;�t�;џ�;�<�;�|��; use std::fs::{self, File};���;��ԏ<ս�<���<96 // Create a directory inside of the current directory���<(% let tmp_dir = TempDir::new_in(".")?;���=A����=0���>4����>"�{<�>�|4�?�����!!ܭ�?��\�?
 ����?��EE��?NK Attempts to make a temporary directory with the specified prefix inside of���@SP `env::temp_dir()`. The directory and everything inside it will be automatically���A5���A�d�A��A���A;���B�t�Bџ�B�<�B�|��B����C��ԭCս�C���C9����D0- let tmp_dir = TempDir::with_prefix("foo-")?;���DIF let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap();���E*' assert!(tmp_name.starts_with("foo-"));���E"�{<�E�|\�E����##�����F����:d�F
"���&4�F')��LE��FNK Attempts to make a temporary directory with the specified suffix inside of���GS����H5���H�d�H��H���I;���I�t�Iџ�I�<�I�|��I����J��ԯJս�J���J9����K0- let tmp_dir = TempDir::with_suffix("-foo")?;���KI����L(% assert!(tmp_name.ends_with("-foo"));���L"�{<�L�|\�L�����%%���M��d�M
$���&4�M��Tw��MKH Attempts to make a temporary directory with the specified prefix inside���NKH the specified directory. The directory and everything inside it will be���OC@ automatically deleted once the returned `TempDir` is destroyed.��O�d�O��O���P;���P�t�Pџ�P�<�P�|��P����Q��ԱQս�Q���Q9����R85 let tmp_dir = TempDir::with_suffix_in("-foo", ".")?;���RI����S(����S"�{<�S�|t�T������'�('(���T�����T��d�T����6\�T
&�����&4�T��TLNHJ��[w��UK����VK����VC���W�d�W��W���W;���X�t�Xџ�X�<�X�|��X����X����Xս�Y���Y9����Y85 let tmp_dir = TempDir::with_prefix_in("foo-", ".")?;���ZI����Z*����["�{<�[�|t�[�������*�+*+���[���[��d�[��\�[
)�����&4�\��\8:=?��b!��]52 Accesses the [`Path`] to the temporary directory.��]���]@���^�t�^џ�^�<�^�|Ը^ս�^���^ let tmp_path;��^�,�^ {���_%"    let tmp_dir = TempDir::new()?;���_,)    tmp_path = tmp_dir.path().to_owned();��_���_85    // Check that the temp directory actually exists.���`"    assert!(tmp_path.exists());��`���`;8    // End of `tmp_dir` scope, directory will be deleted�,�a }��a���a.+ // Temp directory should be deleted by now���a)& assert_eq!(tmp_path.exists(), false);���b"�{<�b�|-\�b$�b���6��6�b
,$�b��d!��c+( Deprecated alias for [`TempDir::keep`].�use TempDir::keep()���c%-\�cL�d���6�,�,��,�*�+����`'�$
-$�d��l ��d[X Persist the temporary directory to disk, returning the [`PathBuf`] where it is located.��e���e\Y This consumes the [`TempDir`] without deleting directory on the filesystem, meaning that���f:7 the directory will no longer be automatically deleted.��f���f]Z If you want to disable automatic cleanup of the temporary directory in-place, keeping the���g>; `TempDir` as-is, use [`TempDir::disable_cleanup`] instead.��g���h$����hFC [`PathBuf`]: http://doc.rust-lang.org/std/path/struct.PathBuf.html��h�t�hџ�i�<�i�|��i
 use std::fs;�Ըiս�i���i"���j���j/, // Persist the temporary directory to disk,���j$! // getting the path where it is.���j" let tmp_path = tmp_dir.keep();��k���k0- // Delete the temporary directory ourselves.���k" fs::remove_dir_all(tmp_path)?;���k"�{<�l�|-\�l$�l�6��
.$�l��q8��m]Z Disable cleanup of the temporary directory. If `disable_cleanup` is `true`, the temporary���n^[ directory will not be deleted when this `TempDir` is dropped. This method is equivalent to���oEB calling [`Builder::disable_cleanup`] when creating the `TempDir`.��o���o_\ **NOTE:** this method is primarily useful for testing/debugging. If you want to simply turn���pSP a temporary directory into a non-temporary directory, prefer [`TempDir::keep`].�|�q���6�q
/$�q�|�q��~(��rEB Closes and removes the temporary directory, returning a `Result`.��r���rGD Although `TempDir` removes the directory on drop, in the destructor���sFC any errors are ignored. To detect errors cleaning up the temporary���t$! directory, call `close` instead.��t�d�t��t���tWT This function may return a variety of [`std::io::Error`]s that result from deleting���uEB the files and directories contained with the temporary directory,���uIF as well as from deleting the temporary directory itself. These errors���v may be platform specific.��v���vIF [`std::io::Error`]: http://doc.rust-lang.org/std/io/struct.Error.html��w�t�wџ�w�<�w�|��w����x��Ԧxս�x���x6�x��y"����yA����y0���z4���z���zC@ // By closing the `TempDir` explicitly we can check that it has���{B����{B? // the directory will still be deleted when `tmp_dir` goes out���|A����}׎��}٣��}����}"�{<�}�|,�~�6��������������������q�aX�8
0$�~�~0<closure_kind>�1<closure_signature>�1<upvars>�1101�6�6䛁�63�3̾�4�����6��62ȁ2
3$Ɂ����65�_5���8�������6��^�^��^��[�^�F�[����e�S����������������������q�aXÅÅą��:����4��4
5$���������67�7�ڃ$݃���66�6
7$��ք�4��������������������;t�����G�G�G�H�G��fq�	K;�����
8�$���'\���|��<����:�4`?ED
$9?�\P:;�<*:<��H<�:=�<O�,:>�Jt#><7.�D!�Y�z�������������������;t����ى���
?�$l�'\�|���2l�t��?ӂC�C��CC?C��ȍ�?ӂD�D��DD?D�6��$,L�B,�BP��<	�,FG�,"	�FI�)	�*FJ�H.	�FK�	H�	;=-/!��	�7M�_M��8	�	�����7��^�^��^��[�^�F�[����e�S��ֆL�	L
M$�	��	��	�7O�O��9	4�	���7����������������;t�����N�	N
O$�	��	\�	P�QPQ�����	����	Pܒ,ܒ2RRR&(��k	l�	���P�S�TTSP��֓�	����	�֓l�	֓����	�����l�	
R���֓��$�	�$�	wyqs��/	�VV���8�	�7WRW��k	l�	�7��7U�X�YXYU�����	����	���l�	���֖�	�֖��l�	
W�8��֖$�	�$�	rtln�	WӂZ�Z��ZZWZ�8��֖�8�8��D�B$�Bv��������,	�[\�,�[]�.�*[^fs�$A�[`�$G�[a�H\M�G[b�H$i�[dRead�$o�[eSeek�$u�[f�D{�I[gWrite�,��[h̗��[i�,��[j�
$��)[l�<��)[m�T��K[n�,��)[o�$��-[q�<��,[r���[s�\�P[t�
<��[uT�|�D)��7"�<vyjm�_,bdRUBE69%(D�|���5������������T��̢�t��<��[w�d����4�	���4����<����$�!��d�
D�
v��������,�wx��$#�wz�$)�w{�H\/�Gw|�HF�w}�#$V�w~�$k�-wrename�4��w�unlink�4��w�	hard_link�L��w�|��"�����<A�\O�|`��v=su]_��H���������6��G�G�G�H�G����%O@?������������������;t����ى��������������������q�aX�=�8�
��$�open_options�d��'\���3t�t���ӂ���������ى�D��3|�w���6ۡ�
��$���	-����6ۡ�	
���	��
T�
4�
L�
,�
��
!t�
��ӂ�����������ۡ����.\�w���6ۡ�
���4��ӂ�����������ۡ��;�����=��6ۡ�
��$��$���SE����6��6˂�
�old_path�D�new_path�D�	overwrite�L���-l�\����,���2T���<�į,�w�Y�YU�Yv��Xb�?e0J����!'B���6˂�!
��!t�
��%��:7 Create a new temporary file. Also see [`tempfile_in`].�����MJ The file will be created in the location returned by [`env::temp_dir()`].���t�ݜ����]Z This variant is secure/reliable in the presence of a pathological temporary file cleaner.�����ݛ����da The temporary file will be automatically removed by the OS when the last handle to it is closed.���pm This doesn't rely on Rust destructors being run, so will (almost) never fail to clean up the temporary file.���d������63 If the file can not be created, `Err` is returned.��	�t�	џ�	�<�	�|ܾ	Ձ��	���	���	1����
݂�
���
0����
"�{<��|D�ۡ
���>��RO Create a new temporary file in the specified directory. Also see [`tempfile`].���t�ݜ����]ǫ��
li If the temporary file isn't created in [`env::temp_dir()`] then temporary file cleaners aren't an issue.�����ݛ����dϬ��p����d������6׮��t�џ��<��|� use tempfile::tempfile_in;���������<9 // Create a file inside of the current working directory���&# let mut file = tempfile_in("./")?;�����0����"�{<��|\���ۡ���ܭ���\�
�������)�8�����-$��9�8��
��,���(�9�����,$��9�9��
��,���&�9��_���8������9��^�^��^��[�^�F�[����e�S��ֆ���
�$�����&�9�����94����9����������������;t���������
�$�����A> A path to a named temporary file without an open file handle.�����OL This is useful when the temporary file needs to be used by a child process,���
 for example.�����`] When dropped, the temporary file is deleted unless `disable_cleanup(true)` was called on the���c` builder that constructed this temporary file and/or was called on either this `TempPath` or the���?< `NamedTempFile` from which this `TempPath` was constructed.�D��9t�6y����|�$�[������|�[��l��9����������%(��(% Close and remove the temporary file.�����?< Use this if you want to detect errors in deleting the file.���d������52 If the file cannot be deleted, `Err` is returned.�� �t� џ� �l� �w��  Є�!���!%" let file = NamedTempFile::new()?;��!���!63 // Close the file, but keep the path to it around.���!%" let path = file.into_temp_path();��"���"EB // By closing the `TempPath` explicitly, we can check that it has���"FC // been deleted successfully. If we don't close it explicitly, the���#GD // file will still be deleted when `file` goes out of scope, but we���$63 // won't know whether deleting the file succeeded.���$ path.close()?;���$"�{<�%�|,�%�9˂��
�$�%�%�ӂ���������������0U��&2/ Persist the temporary file at the target path.��'���'LI If a file exists at the target path, persist will atomically replace it.���(@= If this method fails, it will return `self` in the resulting���( [`PathPersistError`].��(���(FC Note: Temporary files cannot be persisted across filesystems. Also���)>; neither the file contents nor the containing directory are���)FC synchronized, so the update may not yet have reached the disk when���* `persist` returns.��*�t�*ݜ�*���+IF Only use this method if you're positive that a temporary file cleaner���+KH won't have deleted your file. Otherwise, you might end up persisting an��, attacker controlled file.��,�d�,��,���,GD If the file cannot be moved to the new location, `Err` is returned.��-�t�-џ�-�l�-�w��-����. Є�.���.)& let mut file = NamedTempFile::new()?;���.0���/���/%����/&# path.persist("./saved_file.txt")?;���/"�{<�0�|�0���063 [`PathPersistError`]: struct.PathPersistError.html�<�0�9����������������������q�aX�9�����ܭ�0��\�0
���$�1��D�1%'��?v��5VS Persist the temporary file at the target path if and only if no file exists there.��6���6LI If a file exists at the target path, fail. If this method fails, it will���785 return `self` in the resulting [`PathPersistError`].��7���7LI Note: Temporary files cannot be persisted across filesystems. Also Note:���8DA This method is not atomic. It can leave the original link to the���8 temporary file behind.��9�t�9ݜ�9���9I����9K����:���:�d�:��;���;LI If the file cannot be moved to the new location or a file already exists���; there, `Err` is returned.��<�t�<џ�<�l�<�w��< Є��<���<���=)����=0���=���=%����>0- path.persist_noclobber("./saved_file.txt")?;���>"�{<�>�|�>���?6����?�9���������ܭ�?��\�?
���$�?��D�@%'��J:��DKH Keep the temporary file from being deleted. This function will turn the���E?< temporary file into a non-temporary file without moving it.��E�d�E��F���FB? On some platforms (e.g., Windows), we need to mark the file as���F-* non-temporary. This operation could fail.��G�t�Gџ�G�l�G�w��G����G Є�G���H)����H0���H���H%���I let path = path.keep()?;���I"�{<�I�|�I���I6��$�J�9��������������������q�aX���9��
�$�J��R8��N]Z Disable cleanup of the temporary file. If `disable_cleanup` is `true`, the temporary file���O]Z will not be deleted when this `TempPath` is dropped. This method is equivalent to calling���PZW [`Builder::disable_cleanup`] when creating the original `NamedTempFile`, which see for���Q relevant warnings.��Q���Q_����RTQ a temporary file-path into a non-temporary file-path, prefer [`TempPath::keep`].�|�R���9��S�
�$�S�|�S��Y2��S_\ Create a new TempPath from an existing path. This can be done even if no file exists at the�|�T given path.��T���T]Z This is mostly useful for interacting with libraries and external components that provide���ULI files to be consumed or expect a path with no existing file to be given.��V���V_\ When passed a relative path, this function first tries to make it absolute (relative to the���WRO current directory). If this fails, this function uses the relative path as-is.��W���W_\ **DEPRECATED:** Use [`TempPath::try_from_path`] instead to handle the case where looking up���X  the current directory fails.�use TempPath::try_from_path���X-L�Y����9�����������Y�����l�Y
����$�Y)+��bB��^_��|�^���^���_]����_L���`���``] Relative paths are resolved relative to the current working directory. If the passed path is���a\Y empty or if the current working directory cannot be determined, this function returns an�T�b error.��b���bEB **NOTE:** this function does not check if the target path exists.�l�b����������������������q�aX�9�8���������b��l�c
����$�b��g?�g���9��
��$�g�|�g��h�9��_���i8�i�����9��^�^��^��[�^�F�[����e�S��ֆ��i�
�$�i��i��i�9�����j$�j���9��j�
�$�j��k�9�����\�k4�k���6ļk,�k���9��6��k�
�$�k��k�9���̗l4�l���9��6��l�
�$�l��l�9�����l4�l���9��:��l�
�$�l���"ܸm A named temporary file.��m���mGD The default constructor, [`NamedTempFile::new()`], creates files in���nEB the location returned by [`env::temp_dir()`], but `NamedTempFile`���n@= can be configured to manage a temporary file in any location���o52 by constructing with [`NamedTempFile::new_in()`].��o�t�oݜ�o���oGD Most operating systems employ temporary file cleaners to delete old���pMJ temporary files. Unfortunately these temporary file cleaners don't always���qEB reliably _detect_ whether the temporary file is still being used.��q���q>; Specifically, the following sequence of events can happen:��r���rC@ 1. A user creates a temporary file with `NamedTempFile::new()`.���r 2. Time passes.���rOL 3. The temporary file cleaner deletes (unlinks) the temporary file from the���s    filesystem.���sNK 4. Some other program creates a new file to replace this deleted temporary�d�t	    file.���tPM 5. The user tries to re-open the temporary file (in the same program or in a���tLI    different program) by path. Unfortunately, they'll end up opening the���u@=    file created by the other program, not the original file.��v���v)& ## Operating System Specific Concerns��v���vIF The behavior of temporary files and temporary file cleaners differ by���w operating system.��w�|�w ### Windows��w���wNK On Windows, temporary files are, by default, created in per-user temporary���xMJ file directories so only an application running as the same user would be���xLI able to interfere (which they could do anyways). However, an application���yGD running as the same user can still _accidentally_ re-create deleted���yOL temporary files if the number of random bytes in the temporary file name is�t�z too small.��z�l�z
 ### MacOS��z���zKH Like on Windows, temporary files are created in per-user temporary file���{FC directories by default so calling `NamedTempFile::new()` should be���{ relatively safe.��|�l�|
 ### Linux��|���|MJ Unfortunately, most _Linux_ distributions don't create per-user temporary���|OL file directories. Worse, systemd's tmpfiles daemon (a common temporary file���}JG cleaner) will happily remove open temporary files if they haven't been���~%" modified within the last 10 days.��~���~ݛ�~���~A> If the program exits before the `NamedTempFile` destructor is���@= run, the temporary file will not be deleted. This can happen���KH if the process exits using [`std::process::exit()`], a segfault occurs,����PM receiving an interrupt signal like `SIGINT` that is not handled, or by using���OL a statically declared `NamedTempFile` instance (like with [`lazy_static`]).�������FC Use the [`tempfile()`] function unless you need a named file path.�������$Ï���)& [`NamedTempFile::new()`]: #method.new��؂/, [`NamedTempFile::new_in()`]: #method.new_in����O���؃R��l��������;DĄ�;N�+�@=���Ą�=tԄ$Ԅ[���9<�$�[���;��'��������;��_����8�������;��^�^��^��[�^�F�[����e�S��ֆ����
��;$��������(��������;����׆4چ���;��6���
��;$��ˇ!���:7 Error returned when persisting a temporary file fails.�dև�����D��;�{�
g�OE����=����� The underlying IO error.�,�����8�����2/ The temporary file that couldn't be persisted.�$����;���&��������;��_����8�������;��^�^��^��[�^�F�[����e�S��ֆ����
��;$��������+��������8�����,$��;�8��
��;�,����2��������;������3$���;�;��
��;�,���Ό(�����ӌ�;��_����8�������;��^�^��^��[�^�F�[����e�S��ֆ����
��;$��������(��������;������94�����;����������������;t����������
��;$��ĕ��<���������)���&# Create a new named temporary file.�ߏ���+�����t��ݜ������C@ This will create a temporary file in the default temporary file����JG directory (platform dependent). This has security implications on many��ё@= platforms so please read the security section of this type's���� documentation.������� Reasons to use this method:�ْ���IF   1. The file has a short lifetime and your temporary file cleaner is����74      sane (doesn't delete recently accessed files).�����JG   2. You trust every user on your system (i.e. you are the only user).�”��ʔKH   3. You have disabled your system's temporary file cleaner or verified����@=      that your system doesn't have a temporary file cleaner.�ߕ���#  Reasons not to use this method:�������+(   1. You'll fix it later. No you won't.�ǖ��ϖLI   2. You don't care about the security of the temporary file. If none of����IF      the "reasons to use this method" apply, referring to a temporary���DA      file by name may allow an attacker to create/overwrite your����KH      non-temporary files. There are exceptions but if you don't already����*'      know them, don't use this method.����d���ϙ��י6׮���t��џ������<9 Create a named temporary file and write some data to it:����l���w�������� Єћ��ٛ)��������0���Ĝ"�{<��|������$������������������������q�aX�<�8��
����B���A> Create a new named temporary file in the specified directory.�Ǟ��Ϟ This is equivalent to:���l��
 ```ignore����#  Builder::new().tempfile_in(dir)�<���|����ğ-* See [`NamedTempFile::new()`] for details.�������)�4�����������ܭ����\��
����ʠ "��K���IF Create a new named temporary file with the specified filename suffix.������-��������)�\����������������d��
����&4�� "�٦}��IF Create a new named temporary file with the specified filename suffix,���� in the specified directory.�ޤ�������l�������96 Builder::new().suffix(&suffix).tempfile_in(directory)�<ݥ�|����-��������)�t������������������������d���\��
������&4�����?ACE�کK���IF Create a new named temporary file with the specified filename prefix.�����-��������)�\����������������d�
����&4�� "�ѭ}��IF Create a new named temporary file with the specified filename prefix,������֫��ޫ����l�������96 Builder::new().prefix(&prefix).tempfile_in(directory)�<լ�|����-��������)�tح�����������������������d���\��
������&4�����?ACEĒ���������;������������,.ܮ����" Get the temporary file's path.�د�t�ݜ�����HE Referring to a temporary file's path may not be secure in all cases.��ȰKH Please read the security section on the top level documentation of this���� type for details.����t��џͱ�lձ�w�� Є������%������Ʋ" println!("{:?}", file.path());����"�{<���|$�����;��6����
��;$���ȹ$��(��������?����d��������5�����tƵџٵ�l��w�� Є������%��ʶ��ҶJG // By closing the `NamedTempFile` explicitly, we can check that it has����B����:7 // the file will still be deleted when `file` goes out����<9 // of scope, but we won't know whether deleting the file���׎��� file.close()?;����"�{<���|,Ϲ�;˂��
��;$չ���O���2��������L���λ@����� [`PersistError`].�������JG **Note:** Temporary files cannot be persisted across filesystems. Also����>���ǽF����������t��ݜȾ��оIF This method persists the temporary file using its path and may not be����DA secure in all cases. Please read the security section on the top���1. level documentation of this type for details.����d���������G�����t��џ���l���w�������� Є������%��������?< let mut persisted_file = file.persist("./saved_file.txt")?;����:7 writeln!(persisted_file, "Brian was here. Briefly.")?;����"�{<���|������.+ [`PersistError`]: struct.PersistError.html�<���;����������������������q�aX�;�;�����������\��
��;��$����D��,.���Y���V��������L�����0- return `self` in the resulting PersistError.�������EB **Note:** Temporary files cannot be persisted across filesystems.�������`] **Atomicity:** This method is not guaranteed to be atomic on all platforms, although it will����`] generally be atomic on Windows and modern Linux filesystems. While it will never overwrite a����`] file at the target path, it may leave the original link to the temporary file behind leaving����`] you with two [hard links][hardlink] in your filesystem pointing at the same underlying file.����`] This can happen if either (a) we lack permission to "unlink" the original filename; (b) this����ZW program crashes while persisting the temporary file; or (c) the filesystem is removed,����:7 unmounted, etc. while we're performing this operation.����t��ݜ������I�����D�����1�����d���������SP If the file cannot be moved to the new location or a file already exists there,���� `Err` is returned.����t��џ���l���w�������� Є������%��������IF let mut persisted_file = file.persist_noclobber("./saved_file.txt")?;����:�����"�{<���|������74 [hardlink]: https://en.wikipedia.org/wiki/Hard_link�����;���������������\��
��;��$����D��,.���:���K�����?�����d���������B�����-�����t��џ���l���w�������� Є������)�����0��������$! let (file, path) = file.keep()?;����"�{<���|������6��$���;��������������������q�aX�;���;��
��;$�����8���]�����]�����Z�������������_�����OL a temporary file into a non-temporary file, prefer [`NamedTempFile::keep`].�|�����;����
��;$���|��ܲ����+( Get a reference to the underlying file.�<�����;��;����
��;$�����'���30 Get a mutable reference to the underlying file.�\�����;��;����
��;$��������MJ Turn this named temporary file into an "unnamed" temporary file as if you����+( had constructed it with [`tempfile()`].�������UR The underlying file will be removed from the filesystem but the returned [`File`]���� can still be read/written.�L���;�;��
��;$�����'���:7 Closes the file, leaving only the temporary file path.�������JG This is useful when another process must be able to open the temporary�L�� file.�t���;�9��
��;$�����(���A> Converts the named temporary file into its constituent parts.�������_\ Note: When the path is dropped, the underlying file will be removed from the filesystem but����41 the returned [`File`] can still be read/written.�T���;�;�9��
��;$�����2���96 Creates a `NamedTempFile` from its constituent parts.�������JG This can be used with [`NamedTempFile::into_parts`] to reconstruct the���� `NamedTempFile`.�T���;�9�;��
��;�$���$������<����(���'$ Securely reopen the temporary file.�������IF This function is useful when you need multiple independent handles to����KH the same file. It's perfectly fine to drop the original `NamedTempFile`����KH while holding on to `File`s returned by this function; the `File`s will����52 remain usable. However, they may not be nameable.����d���������63 If the file cannot be reopened, `Err` is returned.����t��ݜ������GD Unlike `File::open(my_temp_file.path())`, `NamedTempFile::reopen()`����FC guarantees that the re-opened file is the _same_ file, even in the����52 presence of pathological temporary file cleaners.����t��џ���l���w��� Є������%��������(% let another_handle = file.reopen()?;����"�{<���|4�����<ۡ����
�$�����ӂ������������<���'���������;$���;���������������OQ���7$������;�
�G��������������������q�aX�E�8����
��;$���F�����ӂ����������;���;���Ql�������;�
���
IoSliceMut���������	��������
��;$��bufs�$�����ӂ����������;�������A\������;��G������
��;$���F�����ӂ����������;�������Ct������;��F�F��F��1"`��x9������
��;$���F�����ӂ����������;�������:T������;���˂�ǀ�
��;$̀�FҀɁ�ӂ����������;������"8���<������������������7$������<���������
�8$���F����ӂ����������������Ql�������<�
�������������	��������
�8$����$�����ӂ��������������фA\Ԅ����<��G������
�8$��F���ӂ����������������Ct������<���������
�8$���F�����ӂ����������������:T������<���˂�‡�
�8$LJ�F͇���ӂ����������������)�����Ĉ��;,Lj�;���������������OQ��4,�����;���������
��;$���F��ډ�ӂ����������;�������%,�����;˂����
��;$��ۊ�ӂ����������;�������Kt�������;�
�I�I�IIoSlice��I��һ��x��������
��;$����$�����ӂ����������;�������5L������;���˂�Č�
��;$Ɍ�Fό���ӂ����������;�����܍BLߍ����;����	Arguments���pieces��[����[����[k�ĉ�����˂���
��;$�����ӂ����������;�������#8���<������������������4,������<���������
�8$ď�Fʏ���ӂ��������������Ő%,Ȑ���<˂�ΐ�
�8$Ӑ���ӂ����������������Kt�������<�
�I�I�I���I��һ��x�����Ǒ�
�8$̑��$ґג�ӂ���������������5L������<���˂����
�8$���F��ޓ�ӂ����������������BL������<�����������[����[����[k�ĉ�����˂����
�8$�������ӂ����������������'���������;$���;���#%���4$�����;�I�I�IStart��I��I�IEnd��I��I�ICurrent��I���:41R,��������������������q�aX�8����
��;$ƕ�F̕���ӂ����������;�������"8���<�����4$����<�Ϟ���
�8$��F��˗�ӂ����������������'��������)�;$���;��)�#%���!,�����;�K�K��Kfd��)�K_phantom��)VyL[D�����
��;$˜���-��������)�;<���;��)�#%��L����;����
��;$������d�������٠����������������;t����ى��՝
��$��̡dǝ�'\��$�����ӂ�����������ҍ4���ӂ����������=�<��\�B<�B������D����
\&�����$@����H$T����E4Z�G��ۘ$b����$h����Dn�I����,x����$��-���<��,�����l7��J4�O������tvceԄWYFH��;��GD Create a new [`SpooledTempFile`]. Also see [`spooled_tempfile_in`].���t�ݜ����OL This variant is secure/reliable in the presence of a pathological temporary��� file cleaner.����� # Backing Storage�����b_ By default, the underlying temporary file will be created in your operating system's temporary���[X file directory which is _often_ an in-memory filesystem. You may want to consider using���	]Z [`spooled_tempfile_in`] instead, passing a storage-backed filesystem (e.g., `/var/tmp` on�\�
 Linux).��
���
ݛ�
���
LI The temporary file will be automatically removed by the OS when the last���OL handle to it is closed. This doesn't rely on Rust destructors being run, so���<9 will (almost) never fail to clean up the temporary file.���t�џ��<��|��#  use tempfile::spooled_tempfile;���������(% let mut file = spooled_tempfile(15);��
���
" writeln!(file, "short line")?;���
 assert!(!file.is_rolled());��
���
GD // as a result of this write call, the size of the data will exceed���JG // `max_size` (15), so it will be written to a temporary file on disk,���/, // and the in-memory buffer will be dropped���&# writeln!(file, "marvin gardens")?;��� assert!(file.is_rolled());���"�{<��|���E�>
��*D���V��da Construct a new [`SpooledTempFile`], backed by a file in the specified directory. Use this when,���da e.g., you need the temporary file to be backed by a specific filesystem (e.g., when your default���EB temporary directory is in-memory). Also see [`spooled_tempfile`].�����da **NOTE:** The specified path isn't checked until the temporary file is "rolled over" into a real���`] temporary file. If the specified directory isn't writable, writes to the temporary file will���(% fail once the `max_size` is reached.����E���>���ܭ���\�
����*D���%'��X�������F�����������������;t�����ۡ�
�cursor�4�p�����>���������.��(% Construct a new [`SpooledTempFile`].�-\���E�>��
��*D���I��UR Construct a new [`SpooledTempFile`], backed by a file in the specified directory.�-\�4��E���>�����ܭ���\�
����*D���%'����:7 Returns true if the file has been rolled over to disk.�-\�L����>���
�$���!(�� JG Rolls over to a file on disk, regardless of current size. Does nothing���  if already rolled over.�$�!���>˂��!�
�$�!��#=��",) Truncate the file to the specified size.�<�#���>˂��#�
�$�#�$�#��'&��&63 Consumes and returns the inner `SpooledData` type.�-\�'T�'�>�=��
�$�'��(*��'SP Convert into a regular unnamed temporary file, writing it to disk if necessary.�L�(�>ۡ��
�$�(�*�>�����������������*7$�*����>�������*�
�$�*�F�*��,Ql�,�����>�
�������������	������,�
�$�,��$�,��.A\�.����>��G����.�
�$�.�F�.��0Ct�0����>�������0�
�$�0�F�0��2:T�2����>���˂��2�
�$�2�F�2��4�>�����������44,�4����>�������4�
�$�4�F�4��8Kt�8�����>�
�I�I�I���I��һ��x������8�
�$�8��$�9��=%,�=���>˂��=�
�$�=�?�>�����?4$�?���>�Ϟ��?�
�$�?�F�?D�B$�B���,����D����$1�-���<7�,���HK���repeat_with�\U�H���\vP��������%y{ik�E\^�OD�h5��`<���������Rng����FRt�;(��:��:�E�����*�OB���s��
�rng���&4��&4�rand_len�D�i"���E��ӂ��������������l������6��:��:�E�$��������������������q�aX�$�8�$��$���������������$��������������l�
�����base�$��&4��&4��*T���{}wy��ӂ�����������������\�C�C����	��������$�-���<$�,��OnceLock�D����Dm�JL:<��&��)|�����OnceCell����le]ǂ|����C ������� ��	<��`] Override the default temporary directory (defaults to [`std::env::temp_dir`]). This function���da changes the _global_ default temporary directory for the entire program and should not be called���a^ except in exceptional cases where it's not configured correctly by the platform. Applications���OL should first check if the path returned by [`env::temp_dir`] is acceptable.�����^[ If you're writing a library and want to control where your temporary files are placed, you���^[ should instead use the `_in` variants of the various temporary file/directory constructors���SP ([`tempdir_in`], [`tempfile_in`], the so-named functions on [`Builder`], etc.).�����c` Only the first call to this function will succeed. All further calls will fail with `Err(path)`���HE where `path` is previously set default temporary directory override.�����`] **NOTE:** This function does not check if the specified directory exists and/or is writable.���	���6��������������������q�aX���	
��$�	�
�ӂ���������ߧ������`] Returns the default temporary directory, used for both temporary directories and files if no���&# directory is explicitly specified.�����c` This function simply delegates to [`std::env::temp_dir`] unless the default temporary directory���
;8 has been overridden by a call to [`override_temp_dir`].�����_\ **NOTE:** This function does not check if the returned directory exists and/or is writable.�D���
���ӂ���������ҍ����C*�$�$�$�$�$�$��Cd�$�$�$�$�$�$�$�$%%%%��DU0%0%B%B%T%T%f%f%��G 8�8����@�����G<�G�@��
�88��I�&��&����?���������������I�I��ZܖJ Create a new `Builder`.��J�t�Jџ�J���J>; Create a named temporary file and write some data into it:��K�<�K�|İK use std::ffi::OsStr;���Kο�K���K'$ let named_tempfile = Builder::new()���L$!     .prefix("my-temporary-note")���L     .suffix(".txt")���L     .rand_bytes(5)���M     .tempfile()?;��M��M let name = named_tempfile�|�M     .path()���M-*     .file_name().and_then(OsStr::to_str);��N���N if let Some(name) = name {���N74     assert!(name.starts_with("my-temporary-note"));���N(%     assert!(name.ends_with(".txt"));���OB?     assert_eq!(name.len(), "my-temporary-note.txt".len() + 5);�,�O����O"�{<�P�|�P���P6ω�P�<�P�|��P����Q��İQ����Qο�Q���Q let dir = Builder::new()���R#      .prefix("my-temporary-dir")���R����R     .tempdir()?;��R���R=����S,���S0���T���TD����TB����U>Ǎ��UA����V׎|�V����V����W"�{<�W�|�W���WLI Create a temporary directory with a chosen prefix under a chosen folder:��X�l�X�wԨXο�X���X����X#����Y-*     .tempdir_in("folder-with-tempdirs")?;���Y"�{<�Y�|-\�Y�Z�?��
��&�&��]N��Z! Set a custom filename prefix.��Z���Z0- Path separators are legal but not advisable.���[ Default: `.tmp`.��[�t�[џ�[�<�[�|��[ο�\���\'����\$����\����]"�{<�]�|4�]���?�&��������]������]����:d�]
��&�&��$�]�&4�];=��aN��^! Set a custom filename suffix.��^���^0����_ Default: empty.��_�t�_џ�_�<�_�|��_ο�`���`'����`����`����`"�{<�a�|4�a���?�&���������a����a��d�a
��&�&��$�a�&4�a02��d6��b#  Set the number of random bytes.��b���b Default: `6`.��c�t�cџ�c�<�c�|Զcο�c���c'����d����d����d"�{<�d�|T�d���?�E����e�
��&�&$�erand�$�e��h3��e85 Configure the file to be opened in append-only mode.��f���f Default: `false`.��f�t�fџ�f�<�f�|��fο�g���g'����g     .append(true)���g����g"�{<�h�|4�h���?����h�
��&�&$�h�'4�h��D��i=: Set the permissions for the new temporary file/directory.��i���i # Platform Notes��i�t�j ## Windows��j���j^[ This setting is only fully-supported on unix-like platforms. On Windows, if this method is���j\Y called with a [`Permissions`] object where `permissions.readonly` returns true, creating���k<9 temporary files and directories will fail with an error.��l�\�l ## Unix��l���l[X On unix-like systems, the actual permission bits set on the tempfile or tempdir will be���m]Z affected by the `umask` applied by the underlying syscall. The actual permission bits are���nWT calculated via `permissions & !umask`. In other words, depending on your umask, the���n`] permissions of the created file may be more restrictive (but never more permissive) than the���o ones you specified.��o���o]Z Permissions default to `0o600` for tempfiles and `0o777` for tempdirs. Note, this doesn't���pYV include effects of the current `umask`. For example, combined with the standard umask���qOL `0o022`, the defaults yield `0o600` for tempfiles and `0o755` for tempdirs.��q�\�r ## WASI��r���r]Z While custom permissions are allowed on WASI, they will be ignored as the platform has no���rMJ concept of permissions or file modes (or multiple users for that matter).��s�t�sџ�s���s96 Create a named temporary file that is world-readable.��t�<�t�|��t # #[cfg(unix)]�<�t # {���tο��u*' use std::os::unix::fs::PermissionsExt;��u���u@= let all_read_write = std::fs::Permissions::from_mode(0o666);���vJG let tempfile = Builder::new().permissions(all_read_write).tempfile()?;��v���vB? // Check that this worked and that the file is world-readable.�4�w //���wZW // NOTE: the file likely won't actually be created with 0o666 permissions because it's���x&# // restricted by the user's umask.�4�xȑ��xEB // NOTE: This test will fail if the user's umask is, e.g., 0o066.���yGD let actual_permissions = tempfile.path().metadata()?.permissions();���y96 assert_eq!(actual_permissions.mode() & 0o044, 0o044);�<�z # }���z"�{<�z�|�z���zGD Create a named temporary directory that is restricted to the owner.��{�<�{�|��{�<�{����{ο��{*���|���|;8 let owner_rwx = std::fs::Permissions::from_mode(0o700);���|C@ let tempdir = Builder::new().permissions(owner_rwx).tempdir()?;���}FC let actual_permissions = tempdir.path().metadata()?.permissions();�|�~ assert_eq!(���~.+     actual_permissions.mode() & !0o170000,�t�~     0o700,���~41     "we get the narrow permissions we asked for"�4� );�<�Ԕ��"�{<��|\����?ى����
��&�&$��'\����E��^[ Disable cleanup of the file/folder to even when the [`NamedTempFile`]/[`TempDir`] goes out��ՁRO of scope. Prefer [`NamedTempFile::keep`] and [`TempDir::keep`] where possible;����:7 `disable_cleanup` is provided for testing & debugging.�����PM By default, the file/folder is automatically cleaned up in the destructor of��ȃ\Y [`NamedTempFile`]/[`TempDir`]. When `disable_cleanup` is set to `true`, this behavior is����^[ suppressed. If you wish to disable cleanup after creating a temporary file/directory, call����GD [`NamedTempFile::disable_cleanup`] or [`TempDir::disable_cleanup`].�؅�t�� # Warnings������XU On some platforms (for now, only Windows), temporary files are marked with a special��؆_\ "temporary file" (`FILE_ATTRIBUTE_TEMPORARY`) attribute. Disabling cleanup _will not_ unset����>; this attribute while calling [`NamedTempFile::keep`] will.����t��џ���<���|Ԯ�ο͈��Ո'���     .disable_cleanup(true)���������"�{<��||�����?Ф����
��&�&$���|����/���63 Deprecated alias for [`Builder::disable_cleanup`].�Use Builder::disable_cleanup����.$������?������
��&�&$���$����3�ό$! Create the named temporary file.����t��ݜ������96 See [the security][security] docs on `NamedTempFile`.�ٍ��� # Resource leaking�������IF See [the resource leaking][resource-leaking] docs on `NamedTempFile`.�Ҏ�dڎ�����52 If the file cannot be created, `Err` is returned.����t��џȏ�<Џ�|�܏ο������.+ let tempfile = Builder::new().tempfile()?;����"�{<ݐ�|����2/ [security]: struct.NamedTempFile.html#security����B? [resource-leaking]: struct.NamedTempFile.html#resource-leaking�D�����?������
��&�&$�����N�ڒ?< Create the named temporary file in the specified directory.����t��ݜ������9ۦ��������������Iէ���d���������5ͨӕ�tەџ��<���|Ԃ�ο������52 let tempfile = Builder::new().tempfile_in("./")?;���"�{<���|������2���՗B�\�����?֖���������Ζ���֖�6\��
��&�&֖$���Ƙ?A4���ӂ���������֖�������
��*��&��&��'��'��Gh�@�h���,���NK Attempts to make a temporary directory inside of [`env::temp_dir()`] whose���:7 name will have the prefix, `prefix`. The directory and����?< everything inside it will be automatically deleted once the���$! returned `TempDir` is destroyed.���������������C�����d���������;����t�џ���<���|ԓ�ο������,) let tmp_dir = Builder::new().tempdir()?;���"�{<���|������<��<����?������
��&�&$����G�ʢ;�����@���ϣ5����������������C�����d���������;��ݥ�t�џ���<���|Ԍ�ο������30 let tmp_dir = Builder::new().tempdir_in("./")?;���"�{<���|������<��T����?֖���������Ζ����\��
��&�&֖$�����464é�ӂ���������֖����Ҳ���r���GD Attempts to create a temporary file (or file-like object) using the���EB provided closure. The closure is passed a temporary file path and����LI returns an [`std::io::Result`]. The path provided to the closure will be����FC inside of [`env::temp_dir()`]. Use [`Builder::make_in`] to provide��լC@ a custom temporary directory. If the closure returns one of the����A> following errors, then another randomized file path is tried:���,)  - [`std::io::ErrorKind::AlreadyExists`]����(%  - [`std::io::ErrorKind::AddrInUse`]�����ɮKH This can be helpful for taking full control over the file creation, but����HE leaving the temporary file path construction up to the library. This���IF also enables creating a temporary UNIX domain socket, since it is not����52 possible to bind to a socket that already exists.������JG Note that [`Builder::append`] is ignored when using [`Builder::make`].�ű�tͱݜ����:7 This has the same [security implications][security] as����JG [`NamedTempFile`], but with additional caveats. Specifically, it is up����IF to the closure to ensure that the file does not exist and that such a��ijA> check is *atomic*. Otherwise, a [time-of-check to time-of-use����%" bug][TOCTOU] could be introduced.�������1. For example, the following is **not** secure:���<���|�����ԡ�ο����ȵ // This is NOT secure!���/, let tempfile = Builder::new().make(|path| {�ܛ�     if path.is_file() {����A>         return Err(std::io::ErrorKind::AlreadyExists.into());�L��     }�������IF     // Between the check above and the usage below, an attacker could���LI     // have replaced `path` with another file, which would get truncated�춸     // by `File::create`.�ظ���     File::create(path)�D�� })?;����"�{<���|����ǹIF Note that simply using [`std::fs::File::create`] alone is not correct����85 because it does not fail if the file already exists:�Һ�<ں�|��ο�����������-* // This could overwrite an existing file!��ڻC@ let tempfile = Builder::new().make(|path| File::create(path))?;����"�{<ɼ�|�ռKH For creating regular temporary files, use [`Builder::tempfile`] instead����IF to avoid these problems. This function is meant to enable more exotic�t� use-cases.���������������Iէ���d���������,) If the closure returns any error besides��ѿ,) [`std::io::ErrorKind::AlreadyExists`] or����>; [`std::io::ErrorKind::AddrInUse`], then `Err` is returned.����t��џ<���|����<�������)& use std::os::unix::net::UnixListener;�Խ�ο������IF let tempsock = Builder::new().make(|path| UnixListener::bind(path))?;�<��Ԕ���"�{<���|������HE [TOCTOU]: https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use����2�����B�$�����?֓��������������������q�aX�����[��[N�+�@=��$�8����$������������������֓��6���֓�����������������������q�aX���8l��
��&�&֓��$����������������KH This is the same as [`Builder::make`], except `dir` is used as the base����*' directory for the temporary file path.�������EB See [`Builder::make`] for more details and security implications.����t��џ<���|����<����Ԍ�ο���)��������RO let tempsock = Builder::new().make_in("./", |path| UnixListener::bind(path))?;�<��Ԕ���"�{<���|<�����?�֓������$�������������������������֓��6����֓�����l������6\��
��&�&֓����$��������������\���ӂ���������֓��������֓Բ�E	LL	F�7QPSP�Z���l\	$\	F����to	o	F���8(=	�7��_� "�����7��^�^��^��[�^�F�[����e�S��ֆ�=	�
�,=	��ܻ��?< Error returned when persisting a temporary file path fails.����92vL�;���������Ȕ,����8����74 The temporary file path that couldn't be persisted.�$����9(��9��_�!#�����9��^�^��^��[�^�F�[����e�S��ֆ���
�,��Ȥ���B? A wrapper for the two states of a [`SpooledTempFile`]. Either:�����B? 1. An in-memory [`Cursor`] representing the state of the file.�� 2. A temporary [`File`].�	\��=�u�6-1���������F�=���=�=�"	�"��
��"�"�F�=����|����F�#	�#��
��#�#�=�=����$����=(��=��_�!#�����=��^�^��^��[�^�F�[����e�S��ֆ���
�,���ԥ��KH An object that behaves like a regular temporary file, but keeps data in���IF memory until it reaches a configured size, at which point the data is���LI written to a temporary file on disk, and further operations use the file�d�	 on disk.�
|��>C�0��R����|�D�����E���������,�����=(��>��_�!#�����>��^�^��^��[�^�F�[����e�S��ֆ���
�,���4�;�ӂ����������I�I�I���I��һ��x���E��EA> Create a new temporary file or directory with custom options.�
<�F�&��&����?Gh�@�h��������F�F��FT�F���E��F4�F���&�:��F4�F���&�:d�F4�F����F \�F������������������;t���ى��G|�G��(!�E�&��&����?��_�5858GI�����?��^�^��^��[�^�F�[����e�S��ֆ�!�E�
��&�&,�E��("�E�&��&����?���3636GI���?�?�"�E�
��&�&,�E#�E�&��&����?�������G�NPSU8�_ce���?�#�E�
��&�&�EH$�E�&��&����?����<@�&��&����?�������������?��?�$�E�
��&�&L�E��2u5|!�	Y�����΃!��&Ņ+ԇ0�	6�	<��A��F�L�R��W�\��ay�f�lߓq�wܔ|�������_��������i��i�%�����1�����յ����Dž�:����‰�։���������<��-���
�z�ʅ8�"��*(�0��8��@g�F��Nx�T��\��b׀j��r�x����~����ƃ��}����}����M|�҇�{����Sz�Ky��������x�Ԍ�rw�����^vϏ�u"�t(ؑ0�8�s>��F�rL��TqZʖb1ph�nn4nt�mz���+b���`�R_��^�]��*�f\��,��,�\��.��[��0�P[��2��Z��4�#Z��9�9
�YqY�W�#�*aV0�7�>�OD�GK�GRwDX�B^�Ad3@jJ4pp/v�.|}+�`)��%�$���������o�����h�n�"��������	��	�?
�w�}Y
�)DJ"�������NamedTempFile::new�	tempdir()�fn.tempdir.html��
TempDir::keep�
Builder::make�security implications�time-of-check to time-of-usebug��������܄Builder::append����NamedTempFile::new()���Builder::rand_bytes����std::io::ErrorKind::AddrInUse�߅�std::fs���
env::temp_dir�����std::io::ErrorKind��
�ņ߅env::temp_dir()�
std::fs::File����env::override_temp_dir�������!std::io::ErrorKind::AlreadyExists���ņ�H�
��ԇfn.tempfile.html����temporary file cleaner������Builder::make_in������H�
���ԇ
tempfile()�����=https://github.com/rust-lang-nursery/lazy-static.rs/issues/62�����std::io::Result�ى���Hstd::io�NamedTempFile::keep������lazy_static�����the security���ى������struct.NamedTempFile.html����NamedTempFile::disable_cleanup����!���Builder::disable_cleanup�Builder::tempfile������struct.TempDir.html����ڌ�!�����std::fs::File::create�����spooled_tempfile()�׍���Hthe resource leaking�ڌ�!TempDir::disable_cleanup�:https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use��������ÄŽ׍�H�������������ÄŽ�H�G�܄���������f2http://doc.rust-lang.org/std/path/struct.Path.html�TempDir::path()�����1http://doc.rust-lang.org/std/io/struct.Error.html�TempDir::new()��܄5http://doc.rust-lang.org/std/path/struct.PathBuf.html�std::process::exit()�*http://doc.rust-lang.org/std/fs/index.html�����std::io::Error���ݑ1http://doc.rust-lang.org/std/process/fn.exit.html�TempDir::close()�܄�struct.Builder.html�������Ó�����std::process��3http://doc.rust-lang.org/std/fs/struct.ReadDir.html���׍�Builder::permissions�������������
���0http://doc.rust-lang.org/std/fs/struct.File.html��
׍����ReadDir��ԇޕ�����������
�������
׍����ԇ�ޕ����������.��,����
���-�����
���������ԇ���܄����Ó�ݑ�`���
��(����TempPath::keep�TempPath::try_from_path�NamedTempFile::new_in()�������NamedTempFile::into_parts�'https://en.wikipedia.org/wiki/Hard_link�����
�����struct.PathPersistError.html�����������������
hard links������
������ٛ��������������struct.PersistError.html��������
���ٛ�ԇ�������������������.���
��ԇ�(��������������
����ԇ�(���������������)��E�!�!���)�!�E�!�)����E�G�!��!������
�
�%��
std::env::temp_dir�std::env�������
�
�%�
���
���������
�%�������
��������H���������������I�I�I�H�J��������3P��������H���������������I�I�I�H�J��������3�����)�)P��������H���������������I�I�I�H�J��������3��������H���������������I�I�I�H�J��������3Q�i�B���Es��;�
�e8�_�cg�/#�6s���`�s���xY��y�|���g��M0^M���vѐ�jl�
���Ho)�J��VZ���"��M�!����UCL\6����ԣ�?*�j���������P�ǨD��Y���?�r|��en`��zs.g\��u��H�fE:w�x0���xۃ�I��7	���iހ���5WK��\�	[gջ,$�R*�!i³|�r]��=��b�g]u7>
p�C��ۙ�2����LG2y��%���DL3w>��^�L���qT��(	��se���WY	ge����!��2l��c4����n��t�C�������˽䟉-&i$2/�f0US���Օ��H�I|�ˋ�T�6f��ٳ���J�s��(L'�f����t4��8�ݗ&��F_��]Dwr�P �ݖ>���		��2A����?o����X�����B��Z��$�5k��ཥ�r��-�?���>0b�ru��'����5i�+�_�#�'�?v��x�0MđtZiU(ۏ���ϥ>�&yn~���t/z��\���qŝ���
��
��j�M����N	��Ux����fk��A�ehF�am"R/�xo�:){8��4"dgI,	
�F�Mr��Rq��Hf!��_��C3�׼��5��gG��V�<�Ȧ^Ń;��XA��b�Ռo蓶r�Z����Q��(���V#�7�"a�g�X߅�脜z�#dsn���dC�I�W	+�d�"�6V��k-;��N�?C��P4�&�a��[��wz�`��+bZ��0���_���pe��'N� 7��;�O���i�X��c��N��x�g�g�
^�<�����n$'�qc���m��:x�R�V}I�|#�`�CA �a�
^�
mi���p{Js�㋜gط��_��FG��#,/m}��ڌ~�j'vp�
���lYv������@�k���4���u��+�Ǵ����[Ҿ�L�B�hL�N�7+hj��"��Q�S�=6f��2��;x�.
�#zn6̥���5�O�i~h�2T#�V(��^*��6"���Sl�Ѐ)�֗K?�����>�E��V��{�G5M]�#$�`����
�	�1��D<���ZZ�0��(|T@�/��@�O�"��v%J �&��d�c}�ߺ��F�����1�y�t.� Vj��RrӳW�O��
F��W]ٯ"+k�$�Ѩ֕Z3S���G��M�B%E�M�����B���齿V
'�'���Ϛr�rw�8�B\1�v]o���w�����(���"s�d6�cШ[�$K���:)�1�y��:"�|M'�5��<ہ=��m9��A���OR�P�"h���Z��n��:7v�2��kp����y�v����eܱ �;�C�=����n�1�+�����E�w�E�eY<�ğ_����m�#]��\����ޘ��`/8#$�ߡ�
g%�e�^'��C��dk7��Q}������K�.���[��F:�쭒��Zո�e���y���:(�gM�g���)��Pa�%�A�o�+����c�[��+�ZZ�B�6�I�`��X��=/�{����\���@�[g�9�V�*��~|#*7��p��|��C�=��۞S�k�r�㰒T��l��L�z��3G�M���;/��j)��#���h@|�o������
y#��b�T�#�����G7���P˨�A��7@J�[�<b6���vn�6��̀7����ڵ�5�s5���_�<)��dn>~��hGD>�S����|���s�S��8��!AW��\���҇K����,�J��yF95
�kP�u����?�d�
�`�����)'y���3o��p��5ޣ�YO��X��n`GQ>�r=�kBf0�r�9�ۆ[((��lG�t��#��a��M՜��F�zV:/$n�)]�̧���b�˱���$�r��>���-&�Hߘ�w����C��($i�?�"�n ��`��������`Yf���r2���s���j0���(z���ϔ���r.�O6�ͬ���KK�w;0��"��ʀh�%v�B
��ڜ!����3�؟���O�m=j��{�;�Pp��v=Z��?v��e�c����j
�;y7^�@h����ం\*}�v�G
G�L�d�d�JRMB)	Z�Y-#���8�jM^y�����RW�U�&`�si��YTg���a�&��k/*/L�q�[
N_�xi�hB��>	DhU�pZ"�0�������tf��U� ^��(%�LIܻ��A�Z�1�e��nJ��,<w��?�����J��y�4��n �S�+M�B���A�r�ya[�Ax�p��nf��]@��I\�R�jY�2^41�S=���H���=p���v�e�?�T��-?�[��:z�K�j�y'���:�&�����&ǿ)�@��)�Q>Q���2�݂.waA~H�.Cs�.�c��R����@�Rv*�q����a�N��J�9K1O~�%3'<D0�G�m��i\OgKh�CC�d����p�NV�$Cd3����9A��[%Y#��=~�EN�W�A�a�t�����M�M�����j���R�<��3t�x��H�L�+u$Pfks8�P��'�K�$���yX��N�.NE���=�r�&b�`�\�=��%�i��W����Ӫ��W�]��8�T7'�v�Ӹ���Q:���`�]N	o�aA5uoJ�P�����@R0 �<�_��v��X����9-����śi��m�ap�*ќD��wA^*tJ�楪iz�[-�/�����X�g�v��j~���:���SՌ���m��?�Y��d�H����n$�K�O$�>���a���[���A�<?A�؊�!bg��̤�x?�<i�j��p���š�T%�F�t��r��[���OIJצ��&�e������i?z��J2�C�������?�^��WϠ�[e��p)ogО^�l-tϞ~�3�X���4
��̦��}#Vqt�.�[����3��qe��{��n���49����K��8�Tq��D�9�<�ل�`*��`G�����UX%���&L�L<9<��Z�|₩	��S��C�Q��h؜1!�ў枑�����L;�x��0L��t�sٻ/y��wY�-�8i5�$�E"��=�gބ�����PL*��gW��[G�ܧl=�zU�k�O�g-7�3�&Rͬߡ�)s��GK}�l�r�Vm�p�0x^�J��gs�8g�`�2���TO����[�])F�r?���д*D"�$�s��"�T|��$�l�.j����d�� 
��I��}n~�\ը�>��Oz���_b�~}������<3()9�V,�α��s�N-�!Ȓ�� ��Q��p~n����}�8�4��q*v�i5��U�E��]�B�^���4wN���lU���w_K��a���x\�>Ԡqpc���e?�s�Ҁdg)�����GE�����G`����*b�EMmkac��V}dK�5©�kHzN���!�m�pW������{� N&f���ą	?�v׎��ZW��
�������#�Q�P��H��oUߕ2���6�s���M����e��ߵT�6���a}�y�ў��M�����TS*'x兠�Alq��?�D��#�"�ƀuGVa��=����b���	[z����}�:A�?��X��.�W��o��h��gQbKJ�P[a.LXڱ��Pd{�|�@���k��l�dR��2�el~򺿑G�b�F&=zGqlTƲx8���C�����RP`��[���8X�\�g�d�j���eof]���ܲ�v����SW�iH�A(�j8C�]���L�GQ�"�r[8l�4�{*cl�AӾ=żwY�.�=��W�_Ul�/J���+�G��ʍDur��bg�*���4��[�˒�d�Y��(��;J	�vS8�ГB�4�f��!��3f]�8�+�!F���n��<�<cw�F��/�Q�`�_����������?|V#O/1��<�?������gw����3�kdD��B
d�KY�-���h
ԑr��x���3��L��U$>?�����z�d�;�R�}�/uq�y��s�̭��(�@�@�4�%��)���ԝ����ƻ��Q�M�����8J"��@$^���܅��X�(wR����+��]%2x/�@ʹ��D�� d��=�=Jmsj?�Ǭ��|,&S�Mœ��l�����(If��>�ǣvh��{󪟀��\���B6����!�Z�׿�)rBw�Qv��U̸��[qЂ,�2F�S'ͷ�G㰢�|L���M���M�GXM���G���<':;�r�����&�V�xZK4�P�؀�,�B�����	�h�ܿi�#��h��T%��2p���K_@�Vy��󕀧������y������x���
W��8�o��=��t�
����v
#��N�5J�B������
n�k�`��͌a�[^�@n�<h�����?<�&��y �PJݟ�{	ęrK>�m�^E��i��lY��-�67�9�)9M�N��ʶQ�4z�YI�
�BTv��fcWj�:�u�]� �@p��Y:�S�`zGc\�h0���G?��|���
Kw&�J�:0|^��R�q�֑w���PU��c�#�¶Co�㶣�EQ;T���+&� ��
I����
;�*̃t�_��$���fƬģK7	�s����[\ʖ2|���:$E�	�B�ZU�����YEq��E���ܠ2�^u����P
!�1�@����	��c�2 �I-�C8Ktˏ���A1���a�#�Ê��
�F�a�/����B-��O��B��JaM���R������W��|�d�!�\^�������+���';��}���7D�dNR�~.���R�6V4_V9!�Q��ݠ4֥>"�9s^����Z*/V�]G���C�U��JV�3�Z��
���N$�r�㋏�2r�BΠ<E4�C����} 5U:Р����oA{�V�QEqQ�zۿ������t��)�;�	,�LMjJ{>'�k���;�"�{M����� -���vR��`Xx_ ��W��7_\�?��A�Ri�]���|6�߷�“�Z��AI�^)�����I6���Y:Q5�ll�!�oʾ}�Um:��^S�5T�
���cAv�W������������I�
K����������
���'�+{�%<KPK�K�+L�&R�GVqc�c�cd�fi�k�m�p_rJuvzU%|<�����;�W�|���������I���[���-�H������6�*�n�Y����y�����c��������4���Q�����U�8�U�������
�����x���������g��$�9#�S����z����$�����>�a�z�����J�f��C������C���=���>�~�������Z�����&���!����2����������_�����#�S(���^�j�������F�V�l�T���4���\��z���M���J����t���I�\�0�{�Y�-����r���P	�	%
�
�
��h��
�
6V��G����Gs�&�i��� I!�!^"�"A#�#W$�$.%�%�%8&�&3'P'�'z(|)�)a+�+^,�
,�1�1�3�4�45B5f;*=�>�?KGA<MR�RVmXCY�[�]-U^�lp�p�p�p�pq�qrCr�r�rfs{t�t�t3uKuiuvQwlw�w�w�wmxy�y�y�y	z#z�z�z�z�{�{<|�|�|3}w}�	I�K��������������'�+Jtic�c��G���9���S�D��������������J���V���$��#�����~�������b���6�	���u#�%?'�4D5�p�pr�rZtmt[uGw�w�y�z�{f|$}]}


''�I@KTK�K�R7VKcuc�clf�hZktm�o�qu�u�y|ƀ��m����Ʉ�\�dž]�$���K���ɋ����x�ő��H���f���:��j�ƛ"��k�����>����}�ϱ��ӷ9��e����{�l�����Y�S���h���/�*���<�7���P�N���3���������������U��������J�r���c�`���_rFoC��f	;
�
�L�]��V���F !�!5"�"V#�#l$�$C%�%M&�&e'�'�(�)�+s,1�3�48;�<>�?�@�L�Q�R�U�W�[3]k�n�p�p�pq�q.r�r�r1t�t�t�t�tu5u|u)wUwpw�w�wVy�y�y�y
z'z�z�z�{�|�}u%/K5K8KLK`KgKlKrKxKK�KeLkLqLwL|L�L�L�L�L�L�L�L�L�R�V�Vmc�c�cd�fii�k�k�m�mhpup�p@rMrZrEuvzP|8���ہ6�Q�w������ۄ0�5�:�?�D�������W�������� �$�(�C��
���$�1���%�\�i�;�H�U���������������������������ōˍҍٍލ�������������u�_�d�h�m�q�u�z�������������������^��������
��|�ʒ/���� �&�,�2�:�?�E�M�����P�&�3�P���������Ԝt�����ğ�c���'�4�A�N���h�u�������θ�:�]�v�й�F�b�����������0�=���+�8���'�9�y���������T�������� ������������������v���������@�M�Z�������
�@�M�r��X�e���������@�Q�f�O���!�.���V��t���G���D����n���C�V�*��v�FS�'����m���J	�	
{
�
��c�
�
#0Q��B������@
n���������������e���| D!�!Y"�"<#�#R$�$)%�%�%3&�&/'K'�'N(Q(U(Y(\(`(d(g(k(p(u(d)x)�)C+P+]+�+C,H,K,O,S,Y,�,�1�1�3H4M4S4Y4_4d4j4p4v4|4�4�4�4�4�4�4�4�45o5u5{5a;=%=�>�>�?FA6MR�RV[XhX=Y�[�]�]'^�l�l�l�o�o�o	p�p�p�p�p�p�qr?r�r�rbsxt�t�t�t�t/uFuguvMwhw�w�w�wixy�y�y�y�y�yzz~z�z�z�z�z�{�{�{�{7|r|x|~|�|%}+}1}i}o}u}�}�}�}�}�}~~~~~~!~'~,~1~7~=~B~G~L~Q~W~\~b~g~l~r~x~}~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~$,2:@HNV^dlrz�����������������������$�*�2�8�@�F�N�T�Z�`�f�n�t�{�����������������������Ȁ΀Հۀ������������#�*�0�7�>�D�J�P�V�\�b�h�n�t�z�����������������������Ɓ́ҁ؁ށ����������2K<KPKdKoKuK|K�K�KiLoLuL~L�L�L�L�L�L�L|R"V�VGcqc�cWf�hiEk�k_m�m�ojpwp�qBrOr�t�u�y�{����W����Ą��3�8�=�B�I���Æ��"�&�H����&�6�
��^�n�=�J�ŋ������������������ȍύ֍������������{�b�j�o�s�x�}��������������c����	����4���$�*�0�6�C�I�Q���%�̚(�U���
�ٜg�����)�m�)�׬C�h����j�������$��a�z��f�g�������2�C�-�=���)�c������������&��!���:���8�����x��������B�O���z���}�B���t������?����������#�4�\�z�M�J�t�I\0HY-���P	%
�
��%6�����G�����������A���l�1 � ~! "�"A#�#W$�$.%�%8&�&P'�'S(W(^(b(i(n(s(z(�)E+R+�+F,M,Q,W,^,�0�3P4V4\4g4m4s4y44�4�4�4�4�4�4s5y5#;q<=>�>z?�@�L�Q�R�U�W]Xo[]�]�j�l�l�n�o�o�o�p�p�pq�q*r�r�r-t}t�t�t�t�t3uiu%wQwlw�w�wRy�y�y�y�y�y	z#z�z�z�z�z�{�{�{u|{|�|(}.}l}r}w}�}�}�}�}�}~
~~~~~%~*~/~5~;~@~E~J~O~U~Z~`~e~j~p~v~{~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~�~!)/7=EKS[aiow����������������������!�'�/�5�=�C�K�Q�W�]�c�k�q�x�~���������������������ŀˀҀ؀߀����������� �'�-�4�;�A�G�M�S�Y�_�e�k�q�w�}���������������������ÁɁρՁہ�����������u��RHK\K�RYV�VRcc�c�c}f�hi~k�k�m�mprpprJrWr6u�uz9|)���́&�C�^���Ӄ��Ʌ7���5�؇����و.����"�?�f���E�R�����=����\����}��n���I��0�@�}���ٛ����Ĝc�r�����ПR�����1��K����-�r���������ڸ)�F�o���ܹ5�R������������:����5����4�r�����������>�q�������������������u���s���.�����X�����J�W�v��������J�=�|�C�G���������+�2�^�=�����+���:���\���/���,����2���,�?���V��P�l�z�O�w�	�	
d
�
m�C�_
�
�
-3��"������+�Q��y�Gq���k 3!�!H"�"#�#8$�$%|%�%&�&';'�'2)p)�)�*M+Z+�+|,�1�1�3+4�45@5K;�<"=_>�>�?!AM�Q�R�UXeX�X�[p]�]^�k�l�l,o�o�opPp�p�p�p�p�q�q8r�r�rKs8t�t�t�t�t%u?uWu�u0waw|w�w�wRx�xyy�y�y�yz2z�z�zr{�{|b|�| }Y}�}BKVK�RFV�VLcwc�c�cuf�h
iik�k�m�m�olpyp�qDrQr*u�u�y-|!�M�ǁ�=�Q�~�ƃ�����l�/�̇������(�a���,�`���?�L�j������ߑ+���ߒs�ٓh�֔C��*�:�t���Л�����V�l�����ʟI�x��+���E�ٯ��l�n����	���Ը�@�f���ֹ(�L���n��������4�����/�w���.�i�����
������5�\�������������������]���[����z���@�����D�Q�a���������D�%�v�:�9���y�����"�)�X�/�e���%���	���+������������� ��������s�H��J��^�l�A�i���	�	V
�
_�5yQ
�
�
'%g�X��r��� ��d�=k���^ &!�!?"�"�"�#+$�$%o%�%
&�&'5'�'()g)�)�*G+T+r+v,v1�1�3�3�4�4 5B;�<=C>�>�?AM�Q�R�U�W_X~X�[S]�]�]�k�l�l�n�o�opp�p�p�p�p�q�q/r�r�r=s2t�t�t�t�tu6uQu�u*wXwsw�w�wDx~xYy�y�y�yz)z�z�zd{�{|B|�|}9}�}JK^K�RVTc�c�c�c�f�h�k�mLp$r:uvz=|-���ρ*�E�b���׃��˅;���7�܇�����Q������B����a������p��K��B�����ޛ����Ɯh�t���ßҟW����(����W�������ܸ.�H�t�Ĺ޹:�T�����������"������
�6�w���������C�|�����������������W�o�!�������"�T�H�L���������0�7�`�B�������?���a���4���1����4���1�D���[��q��T�|�	�	
i
�
r�H�d
�
8��'����0�V���Is��p 8!�!M"�"#�#=$�$%�%�%&�&#'='�'4)u)�)
+�+~,�1�1�304�45B5P;�<t>�?&AM�Q�R�U5X�X�[�]^�l�oUp�p�p�p�p�qr=r�r�rPs:t�t�t�t�t,uDuYu�u2wfw�w�w�wWx�x{y�y�y�yz7z�z�zw{�{|d|�|"}[}�}�R8VLcmf�h[kum�o�qu�u�y|����n����]�^�%�M�����z�����I�����;���k���#���l�?�����~�������:�����|�m�Z�T���0�+���=�8���Q�O���4���������������V��������K�s���d�a���`sGpD��g	<
�
	�M�_�W���G 
!�!6"�"W#�#m$�$D%�%N&�&f'�(�)1�3�49;�<>�?�@�L�Q�R�U�W�[4]k�n�pq�q�r2t�tu}u*w�wWy�z�{�|�}�R9Vmf�h\kvm�o�qu�u�y|ǀ��n����]�^�%�Q�����z�Ƒ��I�����;��k�Ǜ#��?����~�б	��շ:�����|�[�U�1�,���>�9���R�P���5������������ ���W��������L�t���e�b���atHqE��h	=
�

�N�_�X���G 
!�!6"�"W#�#m$�$D%�%N&�&f'�(�)1�3�4;;�< >�?�@�L�Q�R�U�W�[7]k�nq�r\t�totu}u�w�z�{�|�}�R&V[f�hIkcm�o�q�t�u�y|��<��\����K���[�L��:�r�Y�����g������Β7���U���)�КY����ݜ-�g�q�۬l�����·(��~���j�H�B�����+�&���?�=���"�����������
���D��������T�9���a�����R���O���y���N�a�5�
{^�2���r��U	�	*
�
�
��h��
;V�G��Ls�E��p5 � �!$"�"E#�#[$�$2%�%<&�&T'~(|)�)a+b,�0�1�3�3�4';u<>~?�@�L�Q�R�U�WmXt["]�]k�npq�r�tuku�wmx�z�{�|y}�dnx<I�������DQ������7AKU_i
!�&s�+�����Vi�k�mtp�pLrYr0��$�h�G�T�2�3�M�t�����<�7�8��
���������������L�Y���L�~�-�R/����O+\+$=�>gX�]�l�l�o�op�!"g"�"�#"f"�"�#�#�t*u"_"�"	"c"�"�R�V�f�h�k�mXp0r>uvzA|1�.�f�������������,���������������P��������m�\��1����`�������3���?���������K������������d�x�.����.�`�P�T���������8�?�G���������������e�y�\��	s
|Rn
@1�8���N��u =!�!R"�"�#B$�$%�%$&�&('�'9)+�1�35a;	=�>�?7A&MR�RVJX�[�]�l�o�qUsv\x�{0|�|�}kc�����,��I�KEc�cŁ;�|�„ބ��-����*�Ë�y�8������e�ȟ�Ҹ>�ԹJ�e����������Z�������_�V�������
����i�"�%3'�'�+�45�p�p�q�r+t{t�tOu#w�wPy�z�{@|�|7}bc������prHt@w�yVcv�����pr<t4w}y����!%)-159CGKOSW[_cgkos������������
")0ELSZju|����������������������								#	0	B	I	]	e	l	p	w	~	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	



!
%
)
-
1
5
9
=
A
E
I
\
a
f
k
p
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

'.6:BFNRZ^fu}�����������'+37?CKSW_ck����������������




&
*
2
:
>
F
N
R
Z
b
j
r
z
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
(9Oasw�����������	#+08=EJNVchuz�����������������	&+/7DHPahmr�����������������#+3DP_qy~�������������������
!&;Dpu|������������������#*.8BJX`nv��������������&.6;KS^bj��������������$16>CJRZlt|������������������$*06<BHNTZ`fmt{������������������#*18?FMT[bipw~������������������
&-4;BIPW^elsz�������������������
")07>ELSZahov}������������������	%,3:AHOV]dkry������dc������prRtetBw�y�c�c�c�c�c�cdddddҁH���:���T�F�����ʜ����������N�S��X�&�!�������	��������������������������������������d���������@�E�J�O�T�"',	!	&	+	0	����������####"#�%�%�%A'�4`5a5b5c5d5e5f5g5h5i5j5k5l5m5�p�r]u�w�z�{h|_}���֌�N�  ��!��'�_ �w)dׁM���?�� �X�K����Ϝ���X��]�+�&�������	�����e��Y�15	����'#�%F'�4n5�p�rbu�w�z�{m|$}d}"�
�}��core_intrinsics�fmt_helpers_for_derive��_�_Q�i�B���z�x�we��\��
Њ
�_�_Q�i�B�����j��3�
�e�f\��
	derive_eq�����Q�i�B���	uJ���L�������Z��Q�i�B�����)�TrKP�Q�i�B����X��W���
�
0��
Њ
�_�_Q�i�B����� �ވ��������Q�i�B��������Y���
���O\��
���Q�i�B�����b��d,��	����
Њ
�_�_Q�i�B������ہ|'���(��Q�i�B�����>˟BT��4	T��Q�i�B��������~�=���E&���Q�i�B���5���۸t
�}�J���
derive_clone_copy���Q�i�B������_E�����
Њ
�_�_Q�i�B���2Mi�J��-��������߄�����0�U����(��������)�Y��������I�q��� �E�������u�������hODHT ���P�"h���`/8#$�ߺ�*ќD��b��'�K�P�_����m�xi�hB��j��p�r����ixۆ[((����R�<��L���&L�L�!��'�:){8��O�#�'�?vB��L�z�h��T%0L'�f���3�[�$K��ks8�POEs��;�B�hL�N���)��P�W�������PJݟ@�p�0x^ܟ�|���g)ogО~B�6�I���eܱ �;����V#�7[Z��$�5<��%���!�P4�&�ac�U�&`�sC��($i��wA^*tJc^�l-tϞ�zV:/$n���M0^M^41�S=/ߕ2�����m��:x�Roo��=��7 �ݖ>�7���?|V`�CA �aq��B��;���UCL\6
���C���<cw�F��/���3G�M����M�GXM�( ��
I���V��v%J �&�/*/L�q��)9M�NE�N�.NE�R
#��N�5J9���RP`����C�Q��h���@R0 �]���Sl�Љ�"�T|���N	��Ux�K=�zU�k���(wR���`��X����E�eY<�Ķ��!�Z�׿!�"�r[8l��`�\�=�TQv��U̸#U� ^��(!��_�u��`�]NZXA��b�ՌX�`zGc\�hLW	+�d�"`�nf��,�%�i��WU7+hj��"����j0��5©�kHzN���O�m=�X��n`GQ�:Q5�ll�!��}#Vqt��o蓶r�Z�Y�J�s��(2R�q�֑Q�L�+u$PfN��?v��ep���v�e1�ǣvh��9K1O~�%3?��?����&��脜z]��TO����G��V�<��V�{� N&��3�Z��
�y#���
g�Tq��D�9�~�3�X�����`�s�V}I�|#�pQ>Q���2�8��:"�|M��[���A�nߘ�w������F�t��rtȒ�� ���4
��̦����n �S�(��š�T%sQ��ݠ4t�j�M����J̭��(�@
]�#$�`����:���ShW��
�������n��<���v׎��Z�[�Ax�p�+v�i5��U��?�Ǭ��|��0���_�fqT��(	$�?�Y��d�j�`*��`G��{M����� �
G�L�d�8i5�$�E����д*D���2p���K1�?�T��-?2����x��5����P
!a	[gջ,$�[���8X�US����.��?�d�
������P���3�؟�
�t4��8��4�n���49��G`����*b�J"��@$^����ԣ���P˨��w���PU�RO6�ͬ��(If��>�
W��8�6`��͌a�<t�_��$�X��fƬģY 5U:Р��~�W���Ôn~�\ը�>�^���4wN���0L�ធ�C�=��ᄳx0���x��w_K��a��d�j���eo�<?A�؊�o��i��lYC���iހ�����ޘ����c����j
����ం\dg)������uq�y��s��G㰢�&���R����kn>~��hGD��l�d�Y	ge����&�Q��p~���X����9_��[G�ܧl��\���@�[���o��h����S��8����NV�$CdD�D�� d��#]��\��
��I��}��x?�<iqGE�������}���7p^)�������
^�<�l��
�	�1��|₩	��S�����y��4�
^�
mi�rJ2�C���z�8�jM^y���
y#���vn�6������P�V�]G���wR�jY�2.-�/���e����m��[���u���X���:]@��I\�-"�$�s����ٳ��1�d�Y���Ho)�J
w����3��KY�-���R*�!i�����#�Q��ϥ>�&yn~F�b�F&=z�_�<)��d�]�8�+�!F��K�.�����ۙ�2���@�4����5�O��ڵ�5�s�O�g-7�3��yF95
��Wj�:�I,<w%�BΠ<E4�||T@�/��	o�aA5uo[x/�@ʹ���dC�I�_q��E��_�FG��#v�lG�t� �I-�Cd�=�=Jmsj�B��JaM�j��^�L���#"��M�!�:(�gM�g���M�M�J��s�N-�!�,&S�Mœ�.���R�6r�	,�LMjJ�V4_V9!�s���xY��yMđtZiUD���Zո���;y7^�@h<�_��v^���b������d�c}��4"dgI,	P�"a�g�X�\��x�g�gk�>	DhU�p���fk��Lٯ"+k�$���=��m9����EMmkac��h@|�o�����\�g��\���qŝ�HH�.Cs�.�:kP�u������vѐ�TS*'x兠�,/m}���wf0�r�9�����H�I|�/݂.waA~9"�ƀuGV�=~�ENG�W�]��8�W���܅��XC����}}a��=��˽䟉-&i,��#��a���R��2�el~���G���<)t��)�;�(ۏ���E�n�1�+��J��y�4'�����E�w�%��)�8Ktˏ���e���H���=0)�@��)�7��pe��'NgZ"�0���-����śi`
��ڜ!��	�?��A�R�㰒T��l�����	�h.�4���u�|�w�����M������o�㶣�EQT�1�@����bC�U��JVx���!�m�p�t�
����v8�`������B%E�M�ݞ�+�Ǵ��}��:)�1�y��D<������ʶQ�4F|^��PQ}��������B-��O�ik��ཥ�r=򺿑G�v�����zf���ą	?��{	ęrKA�+��]%2$2/�f0-<9<��Znj��b�˱����G��ʍDu���V��;�R�}�/��Z��AI��>���a��m�B�����:�������8�4��q*�����UX%�����Q:�Yf]���ܲ�&Rͬߡ�)���VZ����`�������<�&��y ?֥>"�9s^u��Oz���_�|L���M�'�����RW���B�����wY�-��q����a�=�@���k��A1���a�f�������	[z�����c��R���;s.g\��u�����?{��ԝ������j~��gL*��gW��v����S����r.�����&�V+Ռ���m�i��"��jl�
��	��[\ʖ2[�j8C�]��d����pCǨD��Y���?�r|�g�9�V���|���s�H����nk?�"�n ����Y:�SKu�]� �@pJcg�/#�6s��#����ʀh�%v�BL��U$>?�	�~�j'vpx>���-&�H�$�l�.j�ɧ���t/z��Gm"R/�xoN�xZK4�P�,[�<b6���
�e8�_��^Ń;��WA��7@J���W�A�a�H���B6�� [^�@n�<=�H�fE:w�[�])F�r?�W�iH�A(�z�YI�
�G��҇K����gQbKJ�P�d�JRMB)	D�dNR�~qޣ�YO����Q�S�ƻ��Q�M�QEqQ�zۀ齿V
'��RrӳW�O��[a.LXڱ����`Yf������Z*/vd�!�\^��m�en`��z�8g�`�2���e��w����e������X�g�vfA�ehF�aM�楪iz�[dJ��gs��#zn6̥��e��nJ��$��=�r�&bS�)rBw�"����tf�� �y�v��ױ�]Dwr�P63t�x��HM��1�y�t.�e���y������p{Js�s�4�{*c�b�~}�䌬��x�0Ct����IT7'�v��X�>0b�ru?�+����c���5WK��\��Z��n�Ӯ=/�{����p��v=Z
7��p��|�����&ǿ6�l�����h
ԑr�h�����?>�
���lYy�=6f����A�r�ya*�
;�*̃W�(���"��r2���s�wY�.�������YE^��X��.�W�OIJצ��&v�󕀧��3Hf!��S�	�B�ZU].�[����3���A�Z�1#�kp����?z��ykdD��B
d>�m�^EB�c�#�¶CS�ܠ2�^u`)'y���3���N$�r�z:7v�2����W��|�l-���vRȇ��[Ҿ�L�~枑�����i~h�2T#�P��H��oU�ˋ�T�6f0GqlTƲx8�����>�E�n����}��'���Ϛr���[qЂ,�$5����}�y�ў���l�AӾ=��|���:$E\N��J�>I6���Y�i�]�����(z���ϔ��d�� �6�s���M��BTv��fcH+M�B��)����n�)�&��F_�5�b�T�#���,�J�����;�"��[��+�ZZ����;/��j)�M՜��F������j�K>�S��������z�d
��x\�>Ԡ�$�K�O$l�
n�k�;������+�[��:z3�$�r����[e��p}{>'�k���t�C��*[
N_�����Ӫ�V��[�˒�%�LIܻ"9�V,�α�^'��C����m�apadk7�靽�V(����'��@㋜gطtJ�P���\�B�4��؜1!�ў������nZ�Y-#����
g%�e���a�&��k2F�S'ͷ%؀�,�B�-��LG2y DL3w>"_��C3��T���5��gUs�d6�cЦ��̀7�����rw�8�B\�	�vS8���[��F:������:�&�5��L;�x���C�=��������<3()���-�67�9Da�%�A�o�Q�i�B���Kh�CC�B}�:A�?���oA{�Vߺ��F��������G7��s��GK}��0���G?Mw&�J�:0O���K��8�
�F�Mr�Q:��^S�5T�i��YTg�����lU�����[%Y#��FѨ֕Z3S��m��i\OgA�|�r]��=1�v]o���E��]�B���Q�`�_�r��bg�*��#dsn�^�V}dK���Pd{�|��S�k�r��u7>
p�C��Rq��Rn$'�qc��no��p��5�l�r�Vm�?�s�Ҁ��@�Rv*�<�Alq���2��;x�.
�$���yX�Q_@�Vy�2�`Xx_ ��*��~|#*��oʾ}�Um�>�r=�kB�*}�v�G{󪟀��\��b�g]�<�ل��F�a�/��hZZ�0��(�3����9AE"��=�gބ�� Vj������4�qpc���e���N�?C�b㋏�2r{':;�r�*�6V��k-;a�)�֗K?��!AW��\����		��28f��!��3f�?������g�(��;J�#O/1��<��+���';�o���Q��(ZK7	�s��Z��|���
KN�T�6���a���KK�w;0��se���W%`��+bZe��{�G5M�2l��c4(!bg��̤p�^��WϠ|�ܿi�#��/t�sٻ/y����-�?��>�
���cAv���5i�+�_A�^*��6"��x���3��;T���+&�UA����?o�9=��W�_Ul�X��c��Nj��L�GQ���G��M��)]�̧��� 7��;�hj��{�;�P�K�j�y'4?�D��#����I��7	��[��wz�d�@�O�"���
��
�I�
F��W]�|6�߷�ŒA���OR�'�5��<۪'<D0�G�@	��c�2c�����8O���i�i?*�j�����@�k��{�W��7_\��/J���+���qe��{Є{oq{6o4Qu&]e;�=�vS(��A\(HOn3S��	m09s�%��O�&p�������)��n
�0CK�{aJ�G'Y%`4\h\~y_b_6[	'�F4�G��+{'(�J\H322~���������_=�pdN����w9��Lq�@o9	R���t}� N)m[	W>K�^U""%G��,jBC���nT1/tIWBbkiQZa'OBmN7vKS.{xk"��v?6���-�}~2�
>���4I������W�])�MZn<H(l�]qA[JOW?%A|a�x��?=�2�#��G���`�9\�Z�?z��D7Rj�	�:!5rz\}h%��J��<*n��4;��r
���o38F^|DJ�R�S]�P����m�q`?+\,�W4q�?A;cUK'��4E)	4UE(C��+8���;I���n��m<~Hs��9�#��
�%��c`:���zh�v�Y��a�Y	t/�����/B+���KE�rs�����tZv+���)}+���aLG�8PLv9��[���)��8��9r!{�����$dB7���^�
�b������vtA�Y�q�](?u�)m��SMRD	�H���=`���no0-r���RI��1oP�k($Tm1F��i��
EciC���->_k�,�����
0A�9H"���+S*���L��	2"!��MsWdXQ����*"T�����9sxAb"��[���,���Jw�1^��L�ec`����P����xcR2��P�����G�|���=F8VuNr�I]�X��w8NP[vPOq`�`5[����S�����k3hw.hV\m�]C+NQ�~�����*~���P\�3~C/��MU>����z����YYK6@YPA6��!..Y B����2I9��F�F�p33���pu����������G%�0�+-&RPqY�k;/oVS��6���'qe(C�	�}����x�.�a��x�mW��������������V\����@.h{oq{6o4Qu&]e;�=`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/dir/mod.rs� ��ǘ�P
õ!D(����/EB@A$&?PRDTV
<6B15=(#%=*TMDD
<;$B15=(#%=CEE?FH@F(CAHGJC=EF@FEGFEC86##<7-?#?AE%;79%<PL0M2@:'F59A,')*!@E:@#>-F59'C'SX:@#>5N/'L1SX:@#>5N-'L1PPH@#>=N-'<7PPH@#>=N/'<7:E
*1='@
3.'(0*(`a?bC)K'4)'5'''$NbcJdX?/JLK)\JN"N;'F59HGGF'/PL264 ?")#1
04L9Au�<X����N�d/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/dir/imp/mod.rs� ���XGu�D!,
�s	

	���B0e5��a</-/O%a/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/file/mod.rs� ��vf>�.*��q��v��(25T;N 	;N^eq
72 1#(!S^meq
7='1#A@!<,4+3)?K)@BPad@-D:%*;*JKL;'/P67QEKCKNP"L%.5*+';\BLN>#-
[Q=QINP"Q"%.5*5';.(CLN>#-
PDG2%.5*!';A&,!$T6"-
bb_dY?/dbQdWd%29$Y-N:;+
*$
dbQeaJI$!'+1F4*$F*
?#1
  !!HFA6HNF?DPO
QMA*JONMHPLGNPK&BALQPG%*0PS%
*?4+ ;$!7 )?4.35:+?F+@+0HOE$N<OPE(0QNIP/;A%.5')0"F(2.I(N2.R2N$>2.<%8N2.R2N$>2.<%8'MP%*''"-D:%*OG?A'+/7QEOCKNI6L%*D?'3V1'<#8
[Q5Jeeeee_?NI6X%*N?'<`11<#8
PDG2%.5)';A3*H4
bb_dT?30"8.R0Z#"?O.Fd9/>O9,NPP:;LK:%*-'/?9*>CX!+H+J!+A+%>?X!+H+J!+AE,;D,AR"+<+I+&;@,=R"+<DID*;C%;?&*(&0##20#8+'$0!8($.'|a��"�`zi�\ڔ⠡f/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/file/imp/unix.rs� ZWE4Z�z�(T`�_V��!�(
"$_:$AK6
N0"@>I#
0)+[-RV%!01
'>J-2R#%3V%
dG#!! $#!
?#D?&\-E,4
NM(3"*:�ͽ�my��9�\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/env.rs� �4ہ<æ^�ڔ	����3 /S+=aebP__TdIa?/
a'd<`c'0<���^��"R���N\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/lib.rs� V:���nj�� ��mN����b/^ffe-
XaQ^c\`[4 ebd\_cbM`aa# dcf^[cWdad_bca_c_bc_c@7\[Y$#^^]]7N92 1#G! +2+%1'3!%#77>-1EC?B#%#%1ST@6#)' !)
	


4T_B'&#/($$
 C,)"2#<-G
';!(B15IGCF'Q!(2'&5,)'U'
&5,'U'
(,'= 
=,':
BcaA`b\eb^TbR>/EOG_+JL>'L/@HK39'K.
cW?UacL]dC,#'L0
;36#)>N:3'7G:*D>N::'7GU$</*
S?D)H@1'A3)@E:H@8'ANW
LJQKHF1-PMN:O?ONF*64 FNQ"
'N=2H'PNN11C.N'M7GC
*)P/J.W'U
*.?
�d0��؎���=ⰸ�]/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/util.rs� ȓG3J�7椻�O�R! "c&#5!A01a?9M00#+
!(bb!d9eJ#H1 
CMcO(_&*����%V$��h�o`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/spooled.rs� �y�I�?���4[a`��A�: CCLJM
HPc\^MP=$)# HK0'#
>#eeFea)
Y+H[$'4
-5C
ZP0C
?&/,
O /AV
1D)A
 /;=
;-X1U3
 > ?9
X IC
H F@
J IC
A E?
!;*7Y
 @:
R78R'
 JD
, =7
 ; ?9
���Ȝ
=G�V2k�e/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/dir/imp/unix.rs� ���{I�P}[�
B�G�
06$@'(
!*���w���r#�Y^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/error.rs� !��>�J�n�]2��M�-"?:"@"2
22
)�M�e�l�����A�e/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.27.0/src/file/imp/mod.rs� )/^N���ϩ�H_):$�	R*F��Ȗ|bzx�9���NQt����������N�:�����U�x86_64-unknown-linux-gnu��q&ݕ�'�B!�*��-9a6775f13b1e495d�Q�i�B�����
�*�
������)QQ�������������������������	���������������
���������
������������Q�	������
��
�
���
��������%�oQQ��rust-end-file