📄 libtempfile-fb6c0810b9fa4802.rmeta
/home/palash/git/iron_learn/target/debug/deps/libtempfile-fb6c0810b9fa4802.rmeta
Language: rmeta • Lines: 2877
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��E��26��	�>�R$�-a3afb93be10b7b6f�
linux_raw_sys���*����@^x-2e8425f9ea8d5640�bitflags�{Jf�fs��5QJD��-c10f145ac5d2b8b0�	once_cell�7��rrQ)�Ԕ���'-b8023d72a78f6799�fastrand��*.lh5�z���|�86-b1d0e5731e475243�	getrandom���T5֪Wd��T�n�|-ca376ebfba62ea13���v�
їG}�/x$YxD-e720413b8edafa0a��	�-����1ؔ=��G��-e6f0229506bd0299�����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�<�����wpersist�<�!�L�!redox�<�!��!�
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�w�
���������NOSYS�w�v[tempfile�[�
��[��[��[��[��[TempPath�����[���	��
���persist_noclobber��������	from_path��impl Into<PathBuf>���
[��[��[����[��[	��[
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�����:>cy�Tb�-�-��-�*�+{��Gs;*"�_�6��6�_���(��F��(F�����L��_�7��7P��������������������q�aX������
�"�f+�c�8�_���(�����g��\ǜ���8�9������[��[�Ѽױb���9�_�9��9�_�9��9��9��9�6��9�����*�Jp/K�\�_�����[��[�#Q2�#F����;�6�_�������	ޔ�ޛ�I�;��8�;��;�;�_�;��;��;�8�����[��[�#Q2�#F������*�.��g�<���;��<��;��<�)�;�)�;�_����)�����)����2���_���*��*������*�d��������>��>��>�_���
��*��&��&��'��'����.��,S�&�&��?��?���?��?�?����
��*��&��&��'��'����.��,S882������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.���da - Use [`NamedTempFile::new()`] when you need a _named_ temporary file that can be refered 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[�����$� $��H>$�G�H\$�G�Hq$�	��$�-
��$��
�$���$���$���
�$����$���(%���%���$%���!6%���!H%���)Z%���*l%��$$$��A\�A�D��At�A�E|�A $��B#>$>$\$\$<�Bq$|�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�:>cy�Tb7|�/$�/���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�	�8WRW��k	l�	�8��8U�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�|`���=tv^`��I���������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��
��$��$���SF����6��6Ђ�
�old_path�D�new_path�D�	overwrite�L���-l�\����,���2T���<���,�w�Y�YU�Yv��Xb�?e0J����#'C���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��9�Ѽױb�����|�$�[������|�[��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��V2��SLI Create a new TempPath from an existing path. This can be done even if no���T" file exists at the given path.��T���TEB This is mostly useful for interacting with libraries and external���UIF components that provide files to be consumed or expect a path with no���U existing file to be given.�L�V��9�����������V�����l�V
����$�V)+��W?�W���9��
��$�W�|�W��X�9��_���Y8�Y�����9��^�^��^��[�^�F�[����e�S��ۆ��Y�
�$�Y��Y��Y�9�����Z$�Z���9��Z�
�$�Z��[�9�����\�[4�[���6��[,�[���9��6��[�
�$�[�\�9���̤\4�\���9��6��\�
�$�\��\�9���ԁ]4�]���9��:��]�
�$�]��t"��] A named temporary file.��]���]GD The default constructor, [`NamedTempFile::new()`], creates files in���^EB the location returned by [`env::temp_dir()`], but `NamedTempFile`���^@= can be configured to manage a temporary file in any location���_52 by constructing with [`NamedTempFile::new_in()`].��_�t�_��_���`GD Most operating systems employ temporary file cleaners to delete old���`MJ temporary files. Unfortunately these temporary file cleaners don't always���aEB reliably _detect_ whether the temporary file is still being used.��a���a>; Specifically, the following sequence of events can happen:��b���bC@ 1. A user creates a temporary file with `NamedTempFile::new()`.���b 2. Time passes.���bOL 3. The temporary file cleaner deletes (unlinks) the temporary file from the���c    filesystem.���cNK 4. Some other program creates a new file to replace this deleted temporary�d�d	    file.���dPM 5. The user tries to re-open the temporary file (in the same program or in a���eLI    different program) by path. Unfortunately, they'll end up opening the���e@=    file created by the other program, not the original file.��f���f)& ## Operating System Specific Concerns��f���fIF The behavior of temporary files and temporary file cleaners differ by���g operating system.��g�|�g ### Windows��g���gNK On Windows, temporary files are, by default, created in per-user temporary���hMJ file directories so only an application running as the same user would be���hLI able to interfere (which they could do anyways). However, an application���iGD running as the same user can still _accidentally_ re-create deleted���iOL temporary files if the number of random bytes in the temporary file name is�t�j too small.��j�l�j
 ### MacOS��j���jKH Like on Windows, temporary files are created in per-user temporary file���kFC directories by default so calling `NamedTempFile::new()` should be���k relatively safe.��l�l�l
 ### Linux��l���lMJ Unfortunately, most _Linux_ distributions don't create per-user temporary���lOL file directories. Worse, systemd's tmpfiles daemon (a common temporary file���mJG cleaner) will happily remove open temporary files if they haven't been���n%" modified within the last 10 days.��n���n��n���nA> If the program exits before the `NamedTempFile` destructor is���o@= run, the temporary file will not be deleted. This can happen���oKH if the process exits using [`std::process::exit()`], a segfault occurs,���pPM receiving an interrupt signal like `SIGINT` that is not handled, or by using���pOL a statically declared `NamedTempFile` instance (like with [`lazy_static`]).��q���qFC Use the [`tempfile()`] function unless you need a named file path.��r���r$ȏ��r)& [`NamedTempFile::new()`]: #method.new���r/, [`NamedTempFile::new_in()`]: #method.new_in���sO����sR��l�t������;D�t�;�#Q2�#F����t�=t�t$�t[���9<�t$�t[���;��u'������u�;��_���u8�u�����;��^�^��^��[�^�F�[����e�S��ۆ��u�
��;$�u��u��v(������v�;�����v4�v���;��6��v�
��;$�v��w!��w:7 Error returned when persisting a temporary file fails.�d�w�����D�w�;	ޔ�ޛ�I���w�=��x�x The underlying IO error.�,�x���8��x��x2/ The temporary file that couldn't be persisted.�$�x���;��y&������y�;��_���y8�y�����;��^�^��^��[�^�F�[����e�S��ۆ��y�
��;$�y��y��z+������z�8�����z,$�z�;�8��
��;�,�z��{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�̱���� Մ������%������Dz?< 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$���F�����؂�����������������)���������;,���;���������������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���C�ù2�I��:��:�E�����*�OB���s��
�rng���&4��&4�rand_len�D�o"���E��؂���������������l������6��:��:�E�$��������������������q�aX�$�8�$��$���������������$��������������l�
�����base�$��&4��&4��*T���{}wy��؂������������������\�C�C����	��������$�-���<$�,��OnceLock�D����Dm�JL:<��&��)|�����OnceCell����~��`Q]���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���
96 has been override 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�$�$�$�$�$�$%%%%$%$%��DU6%6%H%H%Z%Z%l%l%��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)���L     .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.��{�<�{�|��{dž<�{���{ӿ��{*���|���|;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���؂����������ۖ�������
��*��&��&��'��'����.��,S��,���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`].�ı�ṯ�߱���: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��óA> 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��֟<���|���dž<������)& 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�����[��[�#Q2�#F��$�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��֟<���|���dž<���ԋ�ӿ���)��������RO let tempsock = Builder::new().make_in("./", |path| UnixListener::bind(path))?;�<�������"�{<���|<�����?�ۓ������$�������������������������ۓ��6����ۓ�����l������6\��
��&�&ۓ����$��������������\���؂����������ۓ��������ۓ���E	LL	F�7�����L���l\	$\	F����to	o	F���8(=	�7��_� "�����7��^�^��^��[�^�F�[����e�S��ۆ�=	�
�,=	��ܻ��?< Error returned when persisting a temporary file path fails.����9�g��\ǜ�������Ԍ,����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`].�	\��=��2���������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.�
|��>d���������|�D�����E������մ��,�����=(��>��_�!#�����>��^�^��^��[�^�F�[����e�S��ۆ���
�,���4�;�؂�����������I�I�I���I��һ��x���E��EA> Create a new temporary file or directory with custom options.�
<�F�&��&����?��.��,S�������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��7u:|&�	^�����Ӄ!��&ʅ+ه0�	6�	<��A��F�L�R��W�\��a�f�l�q�w�|�������e��������Y��Y�W�����c��ٶ�����u��u�������y��y�
���}��}�.��%�����	q���/���#�)��1��9^�?��Go�M��U��[��c��k�q��y�~�������}����}����D|�����z����Jz�By��������x����iw������Uv
���u�t!�)�1�s7��?�rE��M	qS׆[(pa�ng+nm~ms��{"b���`�I_��^��\��*�]\��,��,�\��.��[��0�G[��2��Z��4�Z��9��9�Y	hY�W��#XV)�0�7�O=�GD�GKpDQ�BW�A],@cC4ii/o�.uv+{Y)��%�$���������h�	����a�g�������~	��	�8
�p�v�R�	"=C�������env::override_temp_dir�
env::temp_dir��Builder::rand_bytes�std::io::ErrorKind�std::io::ErrorKind::AddrInUse��Builder::append�env::temp_dir()�fn.tempfile.html�
std::fs::File�std::fs��temporary file cleaner������!std::io::ErrorKind::AlreadyExists�������H����
tempfile()������=https://github.com/rust-lang-nursery/lazy-static.rs/issues/62�����Builder::make_in������std::io����HNamedTempFile::keep�����lazy_static�����std::io::Result��������H���
�����struct.NamedTempFile.html�����the security�ʀ���Builder::disable_cleanup�����
����struct.TempDir.html�����NamedTempFile::disable_cleanup���ʀ��Builder::tempfile��
���spooled_tempfile()�����the resource leaking�ƂTempDir::disable_cleanup���std::fs::File::create�����fn.tempdir.html�����̓Ƃ�:https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use�����	tempdir()�����̓
TempDir::keep��time-of-check to time-of-usebug��!����NamedTempFile::new�����ۅsecurity implications���!����������Hۅ
Builder::make�ц��!NamedTempFile::new()�������H����ц��Ƈ�������H�G�������������Ƈf�����std::io::Error��std::process��.0http://doc.rust-lang.org/std/fs/struct.File.html��3http://doc.rust-lang.org/std/fs/struct.ReadDir.html���TempDir::new()�̓Builder::permissions������ReadDir�5http://doc.rust-lang.org/std/path/struct.PathBuf.html����TempDir::path()���1http://doc.rust-lang.org/std/io/struct.Error.html�����̓�std::process::exit()�ۅ��2http://doc.rust-lang.org/std/path/struct.Path.html��������Ӌ��ۅ���*http://doc.rust-lang.org/std/fs/index.html����
��̌���
��1http://doc.rust-lang.org/std/process/fn.exit.html���TempDir::close()�ۅ����Ӌstruct.Builder.html�����
���̌��
����,��܎������������������
�������-�
����������܎���̓��������]����struct.PersistError.html�
hard links����.�
��(������NamedTempFile::new_in()���Ƒ��
���NamedTempFile::into_parts�����������TempPath::keep�������
����������struct.PathPersistError.html��������������
�'https://en.wikipedia.org/wiki/Hard_link��������������������Ƈ�������
������˔�(������������Ƈ���Ƒ�
���������(���˔����Ƈ�*��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��������3S��c� �H1n�TTC#�;c��0測,�/h&ؗ˺@:�����-Y	vV},���Α@�bj�8w'a�	�TA
Ceဘmj��'`L*ȗB1p=[��M1���eV9i���G��=̓�*��
���3U�
.���[�p��_��'ˈ=���F�~&pBJ�y���m݈��4�p���,�l����k������#�:� �5sn�J&8�v�	D^��Y����q���2S�<�f���%2%��!u��6iˠ�u��jgy��O��*n�/V��-���G�$9���rinq��ibAFPi��y��*���R��
��9��������1�cB[����Iu�ӓ�b��D`.�
��u��DFP�'�ֵVG_U�
6���v08N���	�A�H�D����#�It��Ɩ�,*-`5t��?�������O&`͡`y(t��U�h�.����罈*��	�0���rR}�{��^H�eڪ�Ӄ&��@`�Z;y+|�с0��q�=&��S�/���f"���7C6H���K�r�PM�\��pG�
A�0ZW����}j�
Q+�>ؓ��7tb�0�Nv�Q�d�[��*ꟗ~3��Z/�
����ݾ�f�0ֱ���5q�����\�1�#�	]�3L��R���;�Zn��׏l��ɱ�Ξռ����<�;�"��h͕3U��B̃�odd�5^~��s�#���<֭�Q v4k�[Z.Q&3bTIX���Nʜ��:B'�4L��%�賹I��#"�k�t���D���^�ST��ۚ~&cE���˼�ˆ��B�%d���X�wj�Z��~o>6���ĸ-/g]Fnɷ�Ob)m�G�Q
�s���v�;O��f�^v�=2�o1u����P��r�´�ŝw��Q��7njl�<�kRU�N�.S�/3�H�Z���_>BXܠE(Q��&,���=qK��k$���k�����#f¸����{ߑ���f��1�j%w�r��T)�i��r�\�]������t�a
B�E{�iP)g�A�Vz���{˜4�3���M.)xK���$_˯�s�>�H�4�cQx��s���sF-��z*=�a�D�������]M�YN%D��n��𲅫j��(����"���i���K�M�P�ez�����<��|2P�월M�GV�&4�LJ��eX$���4�@�3�B+�ۏJ*�v�܍���^�B�a�?/6	g� �"}
+v��Y#ӳB�w)dO�%k�ٞjhvt��8>���Z��UYWo`��-�$�oJ���C��n}�."���wg���h��H1F|���i�C��L8�M��8G)�f:�᤬��=���(�i�������a"�+ג�)<���{;�CH=/E�
w�g��5ɀ�]d�-��ra�W�L�[j:(�Ñ]�iHƕ�͇�m=>o��lj;�ww@��1���`GA�o7�ĕ�]�i����⿵~���QD?��LDȆ�3�A���V�N��	FMM����G��D;R�k
������@��M�Ŵ�39���q�z[O:[5���2��SY�Sv+��B(0�ZC�>1��H'B�_�q����Jq��e�u&�e2��mzᐂ�|�	:��x…��w2��@�r(����
jm8��YE!���Q�!0��XD�Y���|���M(�B����c�WM�ҟ
aT�¡���ˆ>��ZG�XN{�O��r+�ISL��o�!b��(�Did�!��C�e��*�z��L�Zx�S���UA�~a���@[u��������IK��ſ�4���$a��	M�h6�7O��<���pwR�Ғg������3�jT���r��2��^iR�ƾ'$p���
�?�`
h[sj��;��н���a���i]Z�9K��x�h�Dih���Y�uU�*�d��Y��\`v5�|V��>P⯶~��ٖ����c��W}J���bzo���%䄫<�u�(/'�4?�J��
\?�ڿP
��$�2�	��m�w�m�Q[�������Oû�f���PY��|��
+T��G��)/F�=����i]���w�%*G�~����GM�]�r���JM�ފ=�r�\�i�Z9u��IK�n��$
�X�2;����h#G +�8~��t�.V���78Q��K���h	����,��#t�6㤣z?�����qݛ<��w���������KO>VrS�hq0K���e3�6zX5�h�ZDĝ!�%�P���&G�vg�>��T�k|���)kұf����>l>�a��=ˬ$�	iOq��
���̨C4�zßJ9ؼc�Gp!��Vҷ�hǢ�$�$����
~�?2��P��-�y�`?
I�����`��L)!><t����4��|0�O!&�gD���d�n�M3�5�tqNU0��?���Hwݔ�y9U2��v��p���!��,Ȧ�dGL:/k��#rn�s�\ኅ��&�">cnW0���(��mt��8��#��\|���h�Td`�:�qr�*yy���9Y$�%M�}��NÊ�.?���Lh+�����Í��X�}6���"�9~R�'��!��ynm;Wo��	�A.it�Rk�T��輈�4+�o|P{�O'��]f�m��E�&����M��vy��eO惆��%e��\ŵ㛣�)h�2�q�S?f�I�6�1l��܆��	<<����Nד=!���������_�t�w._z�Zzk�4FW��D�����ŭL�=[�k�({Բ
z��>�܁i�rc�m/�QJ�'$�^_��V6�������QA"��1W��^����{�����2�*CˮG�g�z�P
�g5���"����q��&N�P�V[����8W�a�AZdGG�

��|�3��g!��C��quHh�j���q�U2��%���ֹ+�����ͭ�M�8tK��~"x��ߟ�W���\S��i.��q�!qřt�\<΃:Rz�R��1�Rcޭ)�(S��Fu,�u7���`P�r^E�
	��
&�)p~H|b�;��`�_�T��*�����7���V��wX�j����je��^E���%�!�K�}�(
<'������"gF,?l�H����c��)�'��d��M�}�G��#����=LOݿF<k����~$f徏e�w@{,a��ƒ�9�L��(�MeO'!,���gC�(�EI�����u�lҮWmY�&��}�?1fa������ј)��*�%h�4Ve��
*�G��sU8����o���;Wx�:ۛ�@lb�3��/ҟ��k��èM�N��G��py�0�h�j�d1q2>0���ӊ�.��4�
����0^4cd��^d���(����߷z7�oJ�tz�𳗢�/\��Ni�,yq*�?��A��#�AR�c��g���,�Q@GeM	r�&J�e�ip��d^~��:�S������F,����k�ȶ�빛��b u)�
��h0�<�w�n�e�r�b�o7#a�e+C~�KC\��&�]�>V������kc��p����" �04�{�y���@�m5��z��P���">�T�g���⨋�V_�Õ�ǃ�=��f��k������q�&��5�Ws~����ܛ�3��/W�Y������
8���j�����]��4U���Xy�Hs L;D0�ury���.��Ψ�YP�ZՅ0�~Ϧ���G��45���@����y�5Dȍ���At�?A�$<��y;1�(����d\�B�w'��R毮�j_�3�b�0��"�$�ұ彥�)��2�7 �������u��s�G�Ēb�%.����
�>���?����/J�X٤֎oOg�����'�g�Tʜ�&��,��hz� �#T���5 ��X�ER�����
�4�w�a.�I	�倧��h�!?��������.��3����sL�?��	�Y�BɁ�i�>��n���u�5°b&�w�V�h��y�����Z9x#A�Nv6��{.�n�C�0
�� �or.�<����ҧd��v7�����?{���F���J��x�/��Ҙ}T]!断�8P�yi)�Y�T褞~�g���E
��eV��,�B���g|e�Q9�0c��fHe4n/�36x�^/A��^�����l�����S�P�����z��vZܪ*��{Z�4ك��� <es��8�Y�=˟�+�^3CJ�NȻ��YLcV^�3��.�AI�G�tM๷���#�j
�����i��+�*�v��xD�(w��#��ڦ��"q�8�R��`�r�
z�ёذ�	���n��S�e1@g�*�+��c�_a�f_�A���f
y����=����xfcJs=�Z�j",��i�F�3�T�-�Iqn+ cd1GU6�e��N"k��=��>����D28B���v1=�LJ��p�/K�����W�a_���Ha����}�C�����ʌSP�Ⱥ`��	�m����_5��|�j�~�C��>�S���]1��Jz5�0�G#���#_�u��Cm-k*�����b�&���
�
"r�[�L���c߸�(���W���b™�#��'�5"f$C����E�攁��;��&M
:�H�ex>������!�y�d�4>����4��L:$�+�rv�+XLR���O�(���ᄮHg����#AM���Z-�c���Զ���3��΅�,�|O��p�L�v���1 \H�g;��O�%	)���ե�/��3�u�Iئ �VG!�hX7��m��n�޵ \�Aş���0J1��
�E�\o��?&m�8�K
��jx	c[<
V���b��|�C�>E���ܷ���9�
_������H��З���xyI�x���	sQ(�y�l��,�����VO(j�.������<u`��g�C�~���0qXt^�G�m�+82h��о�Ԕ���(�{)����ftI���U�����.;G�'y�q�F�qe�����@�0U9
s�6����ԕv��:_.�u{s��J���WU�\<OD���yGk��8������M��qx�%@3���F\����Vγ2nG� ��.�.e֦�iQ��'c�xyR�>����C��&����g?k�,gm�a#cPkS�3V2���q�¡ol��\(�8`PUf3�eHp�}�~:��W�W
"��7��/�k6�����R��Q�������7���}�}�}�}�}�I�
K�������� ��
���#�'��%AKUK�K�+L&S�GVvc�c�cd�fi�k�m�pdrOuvzZ%|A�����@�\�����������N���`���2�M������;�/�s�^����~����i��� �����:���W�����[�>�[������������~���������j��$�<#�V������9�V�� �p������"�|����C�����`��S���K���������U������������2�������|�z�E������#�9(�k�D�P���������,�<�R�:������B��`���3���0����Z���/���B��������a���?�l���X���6�f�y�N�j	�	
<��-���
�
-�Y��&��Ov��g/�D�'�= � !!�!"�"#6#�#`$b%�%G'�'D(�
(y-�-�/�0�01cB1J79�:�;/G= IN�N�QQT'U�W�YUZ�h�kjl�l�l�l�l�mn'n�n�nJo_p�p�pq/qMq�q5sPsls�s�sQt�t�u�u�u�uvfv�v�v~w�w xdx�xy[y�	I�K������"��������#�'.pnc�c��L���>��#�X�J����������E��|������B�6�2����x�������i�H��������	���
[��!%#�0(1�l�l�m�n>pQp?q+s�suu�v�wJxyAy


''�IEKYK�K�R<VPczc�cqf�h_kym�o�qu�u�y|ˀ��r����΄�a�̆b�)���P���΋�����~�ˑ��N���l�”@��p�̛(���q�����A������ұ}��k�5�����7��������u�h���s���3�'���/�#�|�6�4������v���y��������;����������0�X�v�I�F�p�E�X�,��U)���L!���2
���
C��<��g,�y�<�R � )!�!3"�"K#�#u$�%�'Y(�,�/�07j8:s;�<�H�M�N�Q�SiWY�f�jol�l�l�l�mnkn�npdp�p�p�p�pq`q
s9sTsps�s:u�u�u�u�uvjv�v�w�xny{%4K:K=KQKeKlKqKwK}K�K�KjLpLvL|L�L�L�L�L�L�L�L�L�L�R�V�Vrc�c�cd�fii�k�k�m�mmpzp�pErRr_rJuvzU|=�Ł��;�V�|����„��5�:�?�D�I�������\���†��!�%�)�-�H�����)�6���*�a�n�@�M�Z�ċ����������������������čʍЍ׍ލ������������
��z�d�i�m�r�v�z����������������������d�����������В5���!�&�,�2�8�@�E�K�S�������V�,�9�V���������ڜz�����ʟ�f���*�7�D�Q����޳�5�Q���l�������x����������N�[��B�O���6�G����������
�P�������������	���������������\�i�v�g�t�&�3�@���������&�3�X�e�>�K���������&�7�L�5�������<���Z���-���*�����T���)���<��������\���,9�
g��S�{�0�a�t�I�e	�		

7��(���{
�
�
&�T������������������Kq���b*�?�"�8 � !{!�!"�"#1#�#4$7$;$?$B$F$J$M$Q$V$[$J%^%�%)'6'C'�')(.(1(5(9(?(�(u-�-�/,01070=0C0H0N0T0Z0`0f0l0q0w0}0�0�0�0�0S1Y1_1E7�8	9|:�:�;*=I�M�N�Q?TLT!U�W�Y�YZ�h�h�h�k�k�k�kgl�l�l�l�l�m�m#n|n�nFo\pxp�p�p�pq*qKq�q1sLshs�s�sMt�t�u�u�u�u�u�uvbv{v�v�v�vyw�w�w�wxVx\xbx�x	yyyMySyYy�y�y�y�y�y�y�y�y�y�y�yzzzzz!z&z+z0z5z;z@zFzKzPzVz\zazfzkzqzwz|z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z{	{{{{%{+{3{;{A{I{O{W{_{e{m{s{{{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{|||||#|+|1|7|=|C|K|Q|X|^|d|j|p|w|}|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|}}
}}}!}'}-}3}9}?}E}K}Q}W}]}e}k}s}y}}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}7KAKUKiKtKzK�K�K�KnLtLzL�L�L�L�L�L�L�L�R'V�VLcvc�c\f�h
iJk�kdm�m�oop|p�qGrTr�t�u�y|���\����Ʉ�8�=�B�G�N����Ȇ�#�'�+�M����+�;���c�s�B�O�ʋ������������������Ǎ͍ԍۍ��������������g�o�t�x�}�����������������i��������:���*�0�6�<�I�O�W���+�Қ.�[����ߜm�����,�p�,�ڬF�k���h���V� �����"����������P�`�D�S���8�o�����������
�����f� ��������^�k��i���(�5���`���c�(���Z�������%�����������	��B�`�3�0�Z�/�B����.?���6���

����
�
-�������������'���R��d�'�= � !�!"�"6#�#9$=$D$H$O$T$Y$`$�%+'8'�',(3(7(=(D(�,�/40:0@0K0Q0W0]0c0i0t0z0�0�0�0W1]17U8�8�9~:^;�<�H�MlN�Q�SATSWY�Y�f�h�h�j�k�k�kll�l�l�l�mngn�npap{p�p�p�pqMq	s5sPsls�s6u�u�u�u�u�u�uvfv�v�v�v�w�w�wYx_x�xyyPyVy[y�y�y�y�y�y�y�y�y�y�yz	zzzzz$z)z.z3z9z>zDzIzNzTzZz_zdzizozuzzzz�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z�z{{{{"{({0{8{>{F{L{T{\{b{j{p{x{~{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{�{|||| |(|.|4|:|@|H|N|U|[|a|g|m|t|z|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|�|}
}}}}$}*}0}6}<}B}H}N}T}Z}b}h}p}v}|}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�}�u�NMKaK�R^V�VWc�c�c�c�f�hi�k�k�m�mpwp�prOr\r;uvz>|.���ҁ+�H�c���؃��΅<���:�݇���ވ3����'�D�k���J�W�����C����b�������t��O�	�6�F�����ߛ����ʜi�x���ğ֟U�����4��N��������A���[�x�����g���ݶ�������6�X���*�L����B�}����������
�;�l�������������������[���Y����f�s�>�q���0�=�\���������0�#�b�)�-���m�������D�#�|������ ���B�����������������%�����g���<�����6��R�`�5�]����J�S�)�E	�	�	
~�o��f
�
�
�7��_�-W���Q�.��u � � b!�!"�"#!#u#%V%�%�&3'@'�'b(f-�-�/0�0�0$1/7�89C:�:�;=�H�M�N�Q�SIT�T�WTY�Y�Y�g�h�hk�k�k�k4lwl�l�l�ltm�mnun�n/opnp�p�p�p	q#q;q�qsEs`s|s�s6t�t]u�u�u�u�uvuv�vVw�w�wFx�xy=y�yGK[K�RKV�VQc|c�c�czf�hink�k�m�m�oqp~p�qIrVr/u�u�y2|&�R�́�B�V���˃��ą�q�4�ч������-�f��!�1�e���D�Q�o�������1����y�ߓn�ܔI���0�@�z���֛����Ĝ\�r�����ПL�{��.���H�ܯ�����;�ڴ�N�r�����Z�~�ж������
�!�R����F�����<�t�����������2�W�������������������C���A�����`�m�&�k���*�7�G���������*��\� ����_�������>��K�������������������s����������������Y���.�r���0��D}R�'iO��y�<wE�_7	{	�	
M��>��X
�
�
�j�J�#Q�u�D�%��h } � U!�!�!�"�"#h#%M%s%w&-':'X'\(\-�-�/�/�0�01&7�89':�:�;�<�H�M�N�Q�SCTbT�W7Y�Y�Y�g�h�h�j�k�k�klql�l�l�lgm�mnln�n!opep�p�p�pqq5q�qs<sWsss�s(tbt=u�u�u�u�u
vlv�vHw�w�w&x�x�xy�yOKcK�R�VYc�c�c�c�f�h�k�mQp)r?uv	zB|2���ԁ/�J�g���܃��Ѕ@���<������V�"���ÐH����g�Ò����v��Q��H���������̜n�z���ɟ؟Z����+����ͳ �C���`�z������l�����������@���4����D�����������@�v���������������r�p�=�U��g������:�.�2���r�������F�(�������%���G�����������������*�����l���A�������W�e�:�b����O�X�.�J	�	�	��
t�k
�
�<��q/Y��V�3��z# � � g!�!"�"	###z#%[%�%�&�'d(h-�-�/0�0�0&147�8X:�;
=�H�M�N�QT�T�WkY�Y�h�k9lyl�l�l�lym�m!nzn�n4opsp�p�p�pq(q=q�qsJses�s�s;t�t_u�u�u�uvvzv�v[w�wxHx�xy?y�y�R=VQcrf�h`kzm�o�q
u�u�y|����s����b�c�*�R�����������O�����A���q���)���r�B���������~��l�6���8�����v�i���4�(���0�$�}�7�5������w���z��������<����������1�Y�w�J�G�q�F�Y�-��V*���M"���3
���
E�=��h-�z�=�S � *!�!4"�"L#x$�%�,�/�07k8:t;�<�H�M�N�Q�SjWY�f�jql�l�m�np�p�paqs�s;u�v�w�xoy�R>Vrf�hak{m�o�q
u�u�y|̀��s����b�c�*�V�������̑��O���ÔA��q�͛)���B������ӱ��l�6�µ8���w�j�5�)���1�%�}�8�6������x���|��������=����������2�Z�x�K�H�r�G�Z�.��W+���N#���4
���
E�>��i-�z�=�S � *!�!4"�"L#x$�%�,�/�07n8:v;�<�H�M�N�Q�SlWY�f�j�l�n@p�pSp�paq�s�v�w�xqy�R+V`f�hNkhm�o�q�t�u�y|��A��a����P���`�Q��?�w�^����m��� ���Ԓ=���[���/�֚_�����0�j�t�ެo���l���Z�$���&���d�W�"������k�%�#������e���h���������*�����������:����G��e���8���5���_���4���G��������a�D�l���X��;�f�y�N�j	!
<�-��
2�Y�+��V�h
�+�A � !�!""�":#d$b%�%G'H(�,y-�/�/�07Y8�9b;�<�H�MqN�Q�SQTXWY�Y�f�j�k�l�n~p�pOq�sQt�v�w�x]y�"jt~BO�������JW������=GQ[eo'�,y�1�����Vi�k�myp�pQr^r5��)�m�L�Y�8�6�P����Z�N�F�����������h�u�s�2�?���2�d��8
��
��5'B'9�:KT�Y�h�h�k�k�k�!"m"�"�#"l"�"�#�#�pq"e"�""i"�"�R�V�fi�k�m]p5rCu
v
zF|6�3�k������������1���������������V�$�������s�_��4������%���e���q���������H���������{�y�J�^�������F�6�:���z������%�-�����������������v�K��_mBj�Yb8T	&s
��z4��[#�8�( � !l!
"�"##%�&m-�/�0E7�8m:�;=
I�M�N�Q.T�W�Y�h�k~m9o�q@tlwx�x�ypc�����(��I�KJc�cʁ@���DŽ�Ɔ2�����/�ȋ�~�>�����œk�Ο9��p��|�����������U�������E�<��������	���
�O�!#�#�'�01jl�l�m�np_p�p3qs�s4u�v�w$x�xygc����*��l�m,p$smu[c|����{l�m psau $6KOSW[_cmquy}�����������������07LSZov}�������������������	
						*	.	2	6	:	>	B	I	M	Z	l	s	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	

	





!
%
)
0
?
C
G
K
O
S
W
[
_
c
g
k
o
s
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

#07;JQY]eiqu}��������������%-19=EIQY]eiq����������������




$
,
0
8
@
D
L
T
X
`
h
p
x
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
.?Ugy}������������$)16>CKPT\in{����������������� $,15=JNVgnsx����������������!)19JVew�������������������	"',AJv{�����������������	
!%)04>HP^ft|�������������
$,4<AQYdhp��������������"*7<DIPX`rz������������������$*06<BHNTZ`flsz�������������������
")07>ELSZahov}������������������	%,3:AHOV]dkry�������������������!(/6=DKRY`gnu|������������������$+29@GNU\cjqx������ic����-��l�m6pIp&spu�cddddddddd	dׁM���?��$�Y�L����М�������G���������D�8����z�����������������������������������������J�����������&�+�0�5�:���
�	���
ijklmno����!�!�!'#�0D1E1F1G1H1I1J1K1L1M1N1O1P1Q1�l�nAq�s�v�wLxCy�}a������� �8!��'� �]%
d܁R���D��%�]�Q���	�՜�L�������I�=������������K���?�
���
p
�!,#�0R1�l�nFq�s�v�wQxyHy���
�}��core_intrinsics�fmt_helpers_for_derive��_�_S��c� ���Do�����\��	��
�_�_S��c� ���e��b��
�e�f\��		derive_eq�����S��c� ��v�M�H0������Z��S��c� ��f��T1� %�S��c� ��X��W���
�	0��	��
�_�_S��c� �v�"9�/0������S��c� ��Sk$U����
���O\��	���S��c� �F&>��C���	����	��
�_�_S��c� �@9�����(��S��c� ����������4	T��S��c� ��*Op�����E&���S��c� �	/��v��Nt
W
}�J���	derive_clone_copy���S��c� �� s-���+�{���	��
�_�_S��c� ����ڀ�������������H����:�>�������h�s�t���*�d�ـ��X�c�ւс.�8��������hODHT ���b�;��`��l��,�h�����Z��M�P���f���PY���	<<V*��
�����
�4�w�?k�,g��`��L)!-݈��4�p�py�0�h���h0�<�%e��\ŵR0測,u,�u}eO'!,���	�0�=�����F� �04�{�����W�a0n�޵ \�AZ����Hd�eX$������M.)xK���'`L*ȗB�Z;y+|��A��4+�oL㛣�)h�2S�,yq*�?���or.�<��cnW0���;=˟�+�^3)��2�7 �4�@�3�B+��ſ�4������y�5D�_U�
6���2T���5 ����.��3����v7����^~��:�Sѳ�S�e1@g� Z�j",&G��=̓��Iqn+ cd)4��L:$�+I�,�Q@Ge�x�^/A��^
�_>BXܠw�{;�CH=/�+��B(0���rv�+XLRJ�H1F|��Ȧ�dGL:/77C6H���E�>�H�4����quHh�jp�IK�n���Lh+�D�"gF,?l���sL�?��p�L�vR �VG!�X���Q�!0�?&m�8�K
^�\<OD���|H1n�TTC#�^�ST�eҟ
aT�¡��">�T�g��~:��W�W
��a�AZdGGmm�Q[�����0^4cd�H'B�_��7���`P�r~\(�8`PUf�v�Q�d�[�L����h�!��(�Did�!��3�jT���	�A.it�J�+82h��oq�¡ol���e�ip��d�3�eHp�}э�@�r(���xfcJs=�%�jhvt��8�xyI�x���f&�)p~H|�[����8Wl7tb�0�NK���Զ�O�sF-��z*�
�������V��-���$��h�Td`?��⨋�V_��H����c����Α@�b{ߑ���}z�ёذjgy��O"��$
�X�2
S��c� �w�r��Tx��ߟ�W�vv�܍��ۚ	�TA
	��i]���wqe�����@v���ҧd������������i���K�]!断�8P�&N�P�Vk�ԕv��:_y�

��|�3n45���@�������Iu-��gC�(�E����罈*�<��g!��Co&�gD���0���Xy��6���ĸ-/k��u��DFP0?��������g��5ɀ�]��>��T�k���,�l/��Ҙ}T��U���s~�?2��P*��Ξռ��VE����g��z��P�����0qXm��,�|O�Q�᤬��=�A�o7�ĕ��K��x�h��?
I����,���c߸�(?�׏l���U��������Y��\`v�P
��$�2�;����h#G�.V���7�<��|2P�9�L��(�M��{Z�4̨C4�z�$řt�\<y��%�!Ӈ%d���X�wi�����c�����D��d�#��\|�>���|���>����D2,��#_�u�:��&����g��$�$(��ftI�r�'ˈ=��y���9YA߷z7�oJ�1p=[��wݔ�y9U4�$�	iO"�&��5����
j�i�Z9u�M1���e
�]f�m��N�월M�G�S�hq0Kˠ�u��!��4�
��M��vy�PZC�>1���2��v��p5�odd�5^Z͡`y(t:�xyR���hz� �#�}�."�������#AMMj�8w'a�uU�*�d����.�.e֦��0U9w�j�d1q2>���%2%����e3�6z
z��>�܁`���C��n��Cm-k;���GM�]_���Ha��1�a.�I	���γ2nG� �8Q��K��E{�iP)g���rR}�{>-Y	vV},D^��Y��m8��YE!����Z-�cNUYWo`��A�~a�����Ēb�%.�f徏e�w@�=��f����P
�g5��i�yi)��#"�k�tcҟ��k��ám;Wo��I��sU8���G�tM���b u)�
�2��mzᐂ�e+C~�K�	)����U���=����$[�p��_��w�n�e�r�ȍ���At������E�C���!��,6Zx�S���U�|���)k�Ws~������u��s�G���?{���F���
��9*@:�����*�+��c�!3��.�AIȺ`��	�m4Ceဘmj�
5����5�|V��>����ј)���zo���%��iQ��'c��L8�M���L��o�!b���0��q�=BJ�y���m��y��(н���a��䄫<�u����ͭ�M�t�*�z��L��E�&����O�賹I�b�&���
=3�u�IئW�N��	FM���ˆ��B�h��ݾ�OD����]�����7����(�i��$�%M�}��Bi�rc�m/�a]�3L��R�S]�iHƕ�Ͷ*�%h�4�/F�=��K�}�(�g|e�Q9�(����"��d��M�}�G�K�r�PMF$a��	M��8G)�f:�k�����{�����l���R��Q�‘?1fa������C�e���ұ彥��_�t�wZ�&��}���M��qx�����
)hX7��m��Y
�s���v�n�:� �5sn@��M�Ŵ���~��篼;O��f�oNÊ�.?CIX���N_�39���q���i�F'=�LJ��.1��
�\���q�U2�q���o���;���^H�eڪ?'��!��ynH�ŭL�=[^1u����P�qD��n���A�Vz�Ʉ=�a�D�@[u�������XD�Y���]�>V���|�	:���q��
���#Ve��
*�G�)�i��r���C�0
�� ��h	���?����8�t�a
B��8tK��~"uez�����C\��&�d\�B�w�D`.�
�/j:(�Ñ��ۏJ*�����k�ҷ�hǢ'�e�u&�e��������8��=6��{.�n�,�B���'�5"f$CBk��#rn�8�-�$�oJ�ĝ!�%�P�™�#��A��/��V�	sQ(�y�gg�C�~�l��*n�/#O��r+�IS�(�{)��q
s�6���x3U�
.���������~���]1��J8���2�*glb�3��/��{˜4�3��1GU6�e�*�&M
:�HE��<�;�"W2S�<�f�#���<֭�\^v�=2�op�q�S?f�ITHs L;D0��ibAFPi'��&G�vg	�A�H�D�4���KO>Vr���O�(�K�D;R�k��)�(S��F|_��V6�cYLcV^��ZG�XN{���]M�YN%�._z�Zzk�[��	�Y�B��;c����eV��A���f
y�#��U�h�.�;��rinq�&��^iR����	��m�w���tqNU02ފ=�r�\�
�:�qr�*y@-`5t��7i.��q�!qx.�u{s��zE�
w��΃:Rz�R�z�X�}6��F�ۚ~&cf�F�~&pBV9i����"�9~R�G
<'��������M(�B���eO惆��Q��|��
+���ˆ>��l>�a��=�!��ᄮHgLd�4>����Hq����Jq��ʜ��:B`�*ꟗ~3�M_�T��*���V��|�j�~�6>���Z���J&8�v�	�wg���hЦ�f����> �3U��B̃YQD?��L�M	r�&J�������#��p����"�j_�3�b��0��"�$�T��G��)Y�T褞~�ك��� <C��>�S79x#A�Nv��r���JM�	�r�´�ŝr�'�ֵVG1�����i�Y�������Ɂ�i�>���w��Q��7ns=LOݿF<k���k$���z������a�j�Z��~o>j]�i�����\�]������g���E
��1���`G�{,a��ƒ����YP�ZՅ���#�������}j�
QI��;�Zn�T0���ӊ�.�����VO(i
8���j���"�+ג��)<�򡟯#��ڦ����vZܪ*�d�-��ra�I�����u��0c��fHes�\ኅ�9����~$��M�N��G������N�W��(��������W���b@���#�It53�H�Z��vX�ER�����k������q�P�����z
��`�r�
�je��^E���!u��6i �����e����
�>��p�/K��/Z.Q&3bT^�ury����+���s�i�C����|0�O!/�&�">:^E�
	��
�Z/�
��N�9�
_��ct^�G�mnf��1�j%~~��s�[�/\��Ni���빛�A�0ZW��H������Y6	g� �"�����!�y�G���1 \HS����#�j
QJ�'$�^bdO�%k�ٟ5°b&�w���)�'����k�({Բ_�xD�(w���+�*�v�m�a#cPk���,��#U�N�.S�/uA"��1W��eS�3V2����DȆ�3�A��Q v4k�[](/'�4?�J���3���Ph6�7O����b�o7#a�G�$9�%es��8�Y�"q�8�R?A�$<��y�,���=qKy��m=>o�Ϸ��
\?�ڿ�y���@�m5���.;G�'t#ӳB�w)����G�������IK����/J�X��'�4L��%a�W�L�[�v08N���3d�n�M3�51�֎oOg����1�Rc�{�3�T�-(��V�Ȅ4FW��\lҮWmY�2��SY�Sv���i]Z�9��z[O:[���\S��w[<
V���`
�?�`
h�^�B�a�?/��ӓ�b��.�1�cB[,��^d���<u`��k�_a�f_�"X5�h�ZD�V�h��y�𲅫j��wX�j�����6�1l���U�E�\o��]�\��pG�
G<���pwR���'$p����n���u����jx	c_��-�y�`+P⯶~���� +�8~��t�%����rlj;�ww@�Dih���Y��0�~Ϧ�V�&4�LJ�����]��4U�&��S�/��C�=!���X��}�C��2���ʌSP�3(��mt<M����G��b��|�C�>a"��7��/�+�>ؓ��Jʜ�&��,���ex>��F��Ɩ�,*6������Qd*���R)���O&`9�%*G�~�}
+v��Y��r��2����J��x��о�Ԕ���pJ���WU{攁��;�D�N"k��=�+t�6㤣z?�f"���D%@3���F�|P{�O'�M4n/�36	�W}J���b����?���ş���0J[j�.�����jf�0ֱ��P�����7��;1�(�����>����C�z5�0�G#�9�.�����Ӄ&��@`@�J9ؼc�%���'�g�T��\�1�#�	R�������+�"����q�j��?���H3�
"r�[�L>jl�<�kRt�Õ�ǃ��g]Fnɷ�lGp!��V&��$_˯�s�CJ�NȻ������_5�5��3��/W��*�����b<yGk��8}Rk�T���K[sj��;��������q�/h&ؗ˺#f¸����|�	���n�Wx�:ۛ�@�E���ܷ��b�A��#�A�Ғg����������S�Ob)m�G�Qmx…��w2��^����{��f8B���v1-y�q�F�u'��R毮��cQx��s���ݛ<��w�R�c��g������c�WM����h�XE(Q��&x�tz�𳗢��g;��O�%T�5q����Q��q��������Oû><t����4.����Í�Ek6����CˮG�g�zh�����kc�,����k�ȵ\����V�P���o-�A,P;3�����84Z���:O#J0 $�Q����[!h7M}Mpvn^hZ22/P|)u\~57x6;VS
P{�#R��2?93��\���U|��C2hBw���q�����?���+'���j���k0/11������*�\m��;� B�����H%(����+/��J�:"O!G}����(G�.����5��6*(}eM,]��Tjd��d	;#�(&����a�
i���;QwIbw3Yt��,%w*'O5V�2s�����#%�RHN8/:Y�}&���p��`���S�=����������@����75��.[rV����s�=�����P1����Nf�� tF�K�:a��?���~\����A���%j�r���E�9e���D*in#dr$6AS[������1~C��6AqGo���v�S��&���A�g\uf��W���M�����E��#&{HeaWr����U�;Kiw@7Wc'8#E�r���~U7-drd
`t��Xx���z#|[w_{;qHp`Q2u7g!Z%TK{Ti)tfRt�%M�Q���$zH7$4�����3M������9]�5#��[CAH�������o�`r�Kbc��Q���l<	8@��k��R!IJSIj	e3���h�a�������!����_����xhATN
VN#���^�v~�75
0���qE�#��p�BG�(\z	��OpDM�2O��������JkF1�:oy�8=_�
��U��J*�}K�C}6���
����4���MA�`��s$/l;
YQ_5���cMZ-%ggpd)<%g_����x�l�-rL�o��ds,;-{d��4	-w�"<tQn��_\m��
��10����l:k ^�F*���qoc:n�vAX()0~,in��U�`���1D%~QAU��!Ig�0�t*�M��$�&)O+9^qw1�^�r�
�]lR B� K\(I`Yx~?���CsfQ��Ws]f
�=1�d+P���o-�A,P;3���`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.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
04�u4.�~#^��8�Sd/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/dir/imp/mod.rs� ���XGu�D!,
�s	

	��4�գ��-B�~S��a/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/file/mod.rs� �|d�����1Y����(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?/Q'JN#91$
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($.'Nuݣ#'��H'����f/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/file/imp/unix.rs� J�d
�}�X��OI�y{�#�(
!"$_:$AK6
N0"@>I#
0)+[-RV%!01
'>J-2R#%3!V%
]G#!! $#
?#D?&\-E,4
NM(3"Y#*B7(0��9�b�J��\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/env.rs� �~�܈ͭ'#��1�����3 /S+=aebP__TdIa?/
a'd:`c'�eNN:/s��_�����\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/lib.rs� K�~y�=� ��R���b/^e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
*.?
m(�0�{����G5]/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/util.rs� �Ts�/�xD�m�u��R! "c&#5!A01a>9M00#+
!(bb!d9eJ#H1 
CMcO(_&*�T
���������<$`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.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
��w��ҒV
2�U_e/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/dir/imp/unix.rs� ���{I�P}[�
B�G�
06$@'(
!*���=��@�k�.ľ<�^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/error.rs� !��>�J�n�]2��M�-"?:"@"2
22
)q�tk�錥w��e/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.24.0/src/file/imp/mod.rs� )/^N���ϩ�H_):$�	R*F@� T�dR�D"h�z-�κw�M���P�����c����x86_64-unknown-linux-gnu�E��h!"�2����-fb6c0810b9fa4802�S��c� ����
�*�
������)QQ�������������������������	���������������
���������
������������Q�	������
��
�
���
��������%�oQQ��rust-end-file