diff --git a/.gitignore b/.gitignore index 1b58495..6de82ca 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,6 @@ wasi2ic lcov.info tarpaulin-report.html + +tests/svg/* +.codegpt \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index cd2bd83..be5ff3f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1493,9 +1493,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e" +checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70" dependencies = [ "serde_derive", ] @@ -1521,9 +1521,9 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e" +checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0" dependencies = [ "proc-macro2", "quote", @@ -1665,7 +1665,7 @@ checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" [[package]] name = "stable-fs" -version = "0.6.5" +version = "0.7.0" dependencies = [ "bitflags", "candid", diff --git a/Cargo.toml b/Cargo.toml index 3a70e2b..d480867 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "stable-fs" -version = "0.6.5" +version = "0.7.0" edition = "2021" description = "A Simple File system implementing WASI endpoints and using the stable structures of the Internet Computer" keywords = ["ic", "internet-computer", "file-system"] @@ -13,8 +13,8 @@ ic-cdk = "0.17.1" ic-stable-structures = "0.6.7" -serde = "1.0.216" -serde_bytes = "0.11" +serde = "1.0.217" +serde_bytes = "0.11.15" ciborium = "0.2.2" [dev-dependencies] diff --git a/src/error.rs b/src/error.rs index 3a279fb..8867874 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,22 +1,314 @@ #[derive(Debug, PartialEq, Eq)] pub enum Error { - NotFound, - InvalidOffset, - InvalidFileType, - InvalidFileName, - InvalidFileDescriptor, - InvalidBufferLength, - InvalidOpenFlags, - InvalidFdFlags, - FileAlreadyExists, - MemoryFileIsNotMounted, - MemoryFileIsMountedAlready, - NameTooLong, - DirectoryNotEmpty, - ExpectedToRemoveFile, - ExpectedToRemoveDirectory, - CannotRemoveOpenedNode, - CannotRemoveMountedMemoryFile, - IncompatibleChunkSize, - InvalidMagicMarker, + // Argument list too long: Too many or too large arguments provided to a program. + // WASI: ERRNO_2BIG + ArgumentListTooLong = 1, + + // Permission denied: Insufficient privileges to perform the operation. + // WASI: ERRNO_ACCES + PermissionDenied = 2, + + // Address in use: Network address or port already in use. + // WASI: ERRNO_ADDRINUSE + AddressInUse = 3, + + // Address not available: The requested address is not available on this system. + // WASI: ERRNO_ADDRNOTAVAIL + AddressNotAvailable = 4, + + // Address family not supported: Unsupported address family (e.g., IPv6 on an IPv4-only system). + // WASI: ERRNO_AFNOSUPPORT + AddressFamilyNotSupported = 5, + + // Resource unavailable or operation would block: Non-blocking operation cannot proceed at this time. + // WASI: ERRNO_AGAIN + ResourceUnavailableOrOperationWouldBlock = 6, + + // Connection already in progress: An operation is already attempting to establish a connection. + // WASI: ERRNO_ALREADY + ConnectionAlreadyInProgress = 7, + + // Bad file descriptor: File descriptor is invalid or closed. + // WASI: ERRNO_BADF + BadFileDescriptor = 8, + + // Bad message: The message is malformed or corrupted. + // WASI: ERRNO_BADMSG + BadMessage = 9, + + // Device or resource busy: The resource is currently in use and cannot be accessed. + // WASI: ERRNO_BUSY + DeviceOrResourceBusy = 10, + + // Operation canceled: The operation was canceled before completion. + // WASI: ERRNO_CANCELED + OperationCanceled = 11, + + // No child processes: No child processes to wait for in a wait operation. + // WASI: ERRNO_CHILD + NoChildProcesses = 12, + + // Connection aborted: The connection was aborted by the host or peer. + // WASI: ERRNO_CONNABORTED + ConnectionAborted = 13, + + // Connection refused: The connection attempt was rejected by the remote host. + // WASI: ERRNO_CONNREFUSED + ConnectionRefused = 14, + + // Connection reset: The connection was forcibly closed by the peer. + // WASI: ERRNO_CONNRESET + ConnectionReset = 15, + + // Resource deadlock would occur: A deadlock was detected and the operation was aborted. + // WASI: ERRNO_DEADLK + ResourceDeadlockWouldOccur = 16, + + // Destination address required: No destination address was provided for a network operation. + // WASI: ERRNO_DESTADDRREQ + DestinationAddressRequired = 17, + + // Mathematics argument out of domain of function: Invalid input for a mathematical operation. + // WASI: ERRNO_DOM + MathematicsArgumentOutOfDomainOfFunction = 18, + + // Reserved error code (not used). + // WASI: ERRNO_DQUOT + Reserved19 = 19, + + // File exists: The file or directory already exists. + // WASI: ERRNO_EXIST + FileExists = 20, + + // Bad address: A memory address is invalid or inaccessible. + // WASI: ERRNO_FAULT + BadAddress = 21, + + // File too large: File size exceeds the system or application limits. + // WASI: ERRNO_FBIG + FileTooLarge = 22, + + // Host is unreachable: The remote host cannot be reached. + // WASI: ERRNO_HOSTUNREACH + HostIsUnreachable = 23, + + // Identifier removed: The requested identifier has been removed. + // WASI: ERRNO_IDRM + IdentifierRemoved = 24, + + // Illegal byte sequence: An invalid or incomplete byte sequence was encountered. + // WASI: ERRNO_ILSEQ + IllegalByteSequence = 25, + + // Operation in progress: A long-running operation is still ongoing. + // WASI: ERRNO_INPROGRESS + OperationInProgress = 26, + + // Interrupted function: The operation was interrupted by a signal or event. + // WASI: ERRNO_INTR + InterruptedFunction = 27, + + // Invalid argument: An argument passed to the function is invalid. + // WASI: ERRNO_INVAL + InvalidArgument = 28, + + // I/O error: A low-level input/output operation failed. + // WASI: ERRNO_IO + IOError = 29, + + // Socket is connected: The socket is already connected to a remote endpoint. + // WASI: ERRNO_ISCONN + SocketIsConnected = 30, + + // Is a directory: The operation is not valid on a directory. + // WASI: ERRNO_ISDIR + IsDirectory = 31, + + // Too many levels of symbolic links: A symbolic link loop was detected. + // WASI: ERRNO_LOOP + TooManyLevelsOfSymbolicLinks = 32, + + // File descriptor value too large: File descriptor number exceeds the allowed range. + // WASI: ERRNO_MFILE + FileDescriptorValueTooLarge = 33, + + // Too many links: The maximum number of hard links has been reached. + // WASI: ERRNO_MLINK + TooManyLinks = 34, + + // Message too large: A network message exceeds the size limit. + // WASI: ERRNO_MSGSIZE + MessageTooLarge = 35, + + // Reserved error code (not used). + // WASI: ERRNO_MULTIHOP + Reserved36 = 36, + + // Filename too long: A file or directory name exceeds the allowed length. + // WASI: ERRNO_NAMETOOLONG + FilenameTooLong = 37, + + // Network is down: The network is currently unavailable. + // WASI: ERRNO_NETDOWN + NetworkIsDown = 38, + + // Connection aborted by network: A network issue caused the connection to be aborted. + // WASI: ERRNO_NETRESET + ConnectionAbortedByNetwork = 39, + + // Network unreachable: The network cannot be accessed. + // WASI: ERRNO_NETUNREACH + NetworkUnreachable = 40, + + // Too many files open in system: System-wide file descriptor limit exceeded. + // WASI: ERRNO_NFILE + TooManyFilesOpenInSystem = 41, + + // No buffer space available: Insufficient buffer space for the operation. + // WASI: ERRNO_NOBUFS + NoBufferSpaceAvailable = 42, + + // No such device: The requested device does not exist. + // WASI: ERRNO_NODEV + NoSuchDevice = 43, + + // No such file or directory: The specified file or directory was not found. + // WASI: ERRNO_NOENT + NoSuchFileOrDirectory = 44, + + // Executable file format error: The file is not a valid executable format. + // WASI: ERRNO_NOEXEC + ExecutableFileFormatError = 45, + + // No locks available: The system has no more locks available for use. + // WASI: ERRNO_NOLCK + NoLocksAvailable = 46, + + // Reserved error code (not used). + // WASI: ERRNO_NOLINK + Reserved47 = 47, + + // Not enough space: Insufficient storage space for the operation. + // WASI: ERRNO_NOMEM + NotEnoughSpace = 48, + + // No message of the desired type: A requested message type is unavailable. + // WASI: ERRNO_NOMSG + NoMessageOfTheDesiredType = 49, + + // Protocol not available: The requested protocol is unavailable. + // WASI: ERRNO_NOPROTOOPT + ProtocolNotAvailable = 50, + + // No space left on device: The storage device is full. + // WASI: ERRNO_NOSPC + NoSpaceLeftOnDevice = 51, + + // Function not supported: The operation is not supported by the system or device. + // WASI: ERRNO_NOSYS + FunctionNotSupported = 52, + + // Socket not connected: The socket is not connected to a remote endpoint. + // WASI: ERRNO_NOTCONN + SocketNotConnected = 53, + + // Not a directory or symbolic link: The target is not a directory or valid symbolic link. + // WASI: ERRNO_NOTDIR + NotADirectoryOrSymbolicLink = 54, + + // Directory not empty: Cannot delete a directory that is not empty. + // WASI: ERRNO_NOTEMPTY + DirectoryNotEmpty = 55, + + // State not recoverable: A persistent state could not be restored. + // WASI: ERRNO_NOTRECOVERABLE + StateNotRecoverable = 56, + + // Not a socket: The file descriptor is not a socket. + // WASI: ERRNO_NOTSOCK + NotASocket = 57, + + // Not supported or operation not supported on socket: Unsupported operation on the socket. + // WASI: ERRNO_NOTSUP + NotSupportedOrOperationNotSupportedOnSocket = 58, + + // Inappropriate I/O control operation: The ioctl operation is inappropriate for the device. + // WASI: ERRNO_NOTTY + InappropriateIOControlOperation = 59, + + // No such device or address: The device or address does not exist. + // WASI: ERRNO_NXIO + NoSuchDeviceOrAddress = 60, + + // Value too large to be stored in data type: A value exceeds the data type's range. + // WASI: ERRNO_OVERFLOW + ValueTooLargeToBeStoredInDataType = 61, + + // Previous owner died: The previous owner of a mutex or resource has died. + // WASI: ERRNO_OWNERDEAD + PreviousOwnerDied = 62, + + // Operation not permitted: The operation is prohibited by the system or security policy. + // WASI: ERRNO_PERM + OperationNotPermitted = 63, + + // Broken pipe: A connection was closed while writing data. + // WASI: ERRNO_PIPE + BrokenPipe = 64, + + // Protocol error: A protocol error occurred during communication. + // WASI: ERRNO_PROTO + ProtocolError = 65, + + // Protocol not supported: The protocol is not supported by the system. + // WASI: ERRNO_PROTONOSUPPORT + ProtocolNotSupported = 66, + + // Protocol wrong type for socket: The protocol does not match the socket type. + // WASI: ERRNO_PROTOTYPE + ProtocolWrongTypeForSocket = 67, + + // Result too large: The result of an operation exceeds the allowable limit. + // WASI: ERRNO_RANGE + ResultTooLarge = 68, + + // Read-only file system: Attempted to modify a read-only file system. + // WASI: ERRNO_ROFS + ReadOnlyFileSystem = 69, + + // Invalid seek: An invalid file seek operation was attempted. + // WASI: ERRNO_SPIPE + InvalidSeek = 70, + + // No such process: The specified process does not exist. + // WASI: ERRNO_SRCH + NoSuchProcess = 71, + + // Reserved error code (not used). + // WASI: ERRNO_STALE + Reserved72 = 72, + + // Connection timed out: The connection attempt timed out. + // WASI: ERRNO_TIMEDOUT + ConnectionTimedOut = 73, + + // Text file busy: An attempt to modify an in-use text file. + // WASI: ERRNO_TXTBSY + TextFileBusy = 74, + + // Cross-device link: An operation attempted to link across different devices. + // WASI: ERRNO_XDEV + CrossDeviceLink = 75, + + // Extension capabilities insufficient: The required extension capabilities are missing. + // WASI: ERRNO_NOTCAPABLE + ExtensionCapabilitiesInsufficient = 76, } + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self) + } +} + +impl std::error::Error for Error {} diff --git a/src/fs.rs b/src/fs.rs index 9f7b40f..baa7689 100644 --- a/src/fs.rs +++ b/src/fs.rs @@ -15,18 +15,17 @@ use crate::{ }, }; -pub use crate::runtime::fd::Fd; - pub use crate::runtime::types::{ - ChunkSize, ChunkType, DstBuf, DstIoVec, FdFlags, FdStat, OpenFlags, SrcBuf, SrcIoVec, Whence, + Advice, ChunkSize, ChunkType, DstBuf, DstIoVec, Fd, FdFlags, FdStat, OpenFlags, SrcBuf, + SrcIoVec, Whence, }; pub use crate::storage::types::FileSize; // The main class implementing the API to work with the file system. pub struct FileSystem { - root_fd: Fd, - fd_table: FdTable, - names_cache: FilenameCache, + pub(crate) root_fd: Fd, + pub(crate) fd_table: FdTable, + pub(crate) names_cache: FilenameCache, pub storage: Box, } @@ -46,7 +45,7 @@ impl FileSystem { let root_node = storage.root_node(); let root_entry = Dir::new(root_node, FdStat::default(), &*storage)?; - let root_fd = fd_table.open(FdEntry::Dir(root_entry)); + let root_fd = fd_table.open_root(FdEntry::Dir(root_entry)); let names_cache = FilenameCache::new(); Ok(Self { @@ -57,19 +56,13 @@ impl FileSystem { }) } - pub fn flush(&mut self, fd: Fd) -> Result<(), Error> { - let node = self.get_node(fd)?; - self.storage.flush(node); - - Ok(()) - } - - // + // Get version of the file system pub fn get_storage_version(&self) -> u32 { self.storage.get_version() } // Get the file descriptor of the root folder. + // This file descriptor is always open and cannot be closed or renumbered. pub fn root_fd(&self) -> Fd { self.root_fd } @@ -79,37 +72,109 @@ impl FileSystem { "/" } + // advice on the usage of the file system, + // this implementation doesn't take any special action, only checks that the Fd is valid. + pub fn advice( + &mut self, + fd: Fd, + _offset: FileSize, + _len: FileSize, + _advice: Advice, + ) -> Result<(), Error> { + let meta = self.metadata(fd)?; + + // this method only works for regular files + if meta.file_type != FileType::RegularFile { + return Err(Error::BadFileDescriptor); + } + + Ok(()) + } + + // The method tries to reserve enough memory for the file. + // If the file is hosting a mounted memory, the memory will actually grow and take more space, + // the regular file will only change its size (no additional memory is consumed by its chunks). + // This method might fail if the resulting file size is above the maximum allowed file size. + pub fn allocate( + &mut self, + fd: Fd, + _offset: FileSize, + _additional_size: FileSize, + ) -> Result<(), Error> { + let meta = self.metadata(fd)?; + + if meta.file_type != FileType::RegularFile { + return Err(Error::BadFileDescriptor); + } + + // TODO: do make file bigger by the given file size + Ok(()) + } + + // Close the opened file and release the corresponding file descriptor. + pub fn close(&mut self, fd: Fd) -> Result<(), Error> { + if fd == crate::runtime::fd::ROOT_FD { + // we do not close the root fd, + // and there is no error in trying to close it + return Ok(()); + } + + // flush if regular file + match self.fd_table.get(fd) { + Some(FdEntry::File(file)) => { + self.storage.flush(file.node); + } + Some(FdEntry::Dir(_dir)) => { + // directories do not need flush + } + None => Err(Error::BadFileDescriptor)?, + }; + + self.fd_table.close(fd).ok_or(Error::BadFileDescriptor)?; + + Ok(()) + } + + // Flush any cached changes to the disk. + pub fn flush(&mut self, fd: Fd) -> Result<(), Error> { + let file = self.get_file(fd)?; + + self.storage.flush(file.node); + + Ok(()) + } + // Reassign a file descriptor to a new number, the source descriptor is closed in the process. // If the destination descriptor is busy, it is closed in the process. pub fn renumber(&mut self, from: Fd, to: Fd) -> Result<(), Error> { self.fd_table.renumber(from, to) } - fn get_node(&self, fd: Fd) -> Result { + pub(crate) fn get_node(&self, fd: Fd) -> Result { match self.fd_table.get(fd) { Some(FdEntry::File(file)) => Ok(file.node), Some(FdEntry::Dir(dir)) => Ok(dir.node), - None => Err(Error::NotFound), + None => Err(Error::BadFileDescriptor), } } - fn get_file(&self, fd: Fd) -> Result { + pub(crate) fn get_file(&self, fd: Fd) -> Result { match self.fd_table.get(fd) { Some(FdEntry::File(file)) => Ok(file.clone()), - Some(FdEntry::Dir(_)) => Err(Error::InvalidFileType), - None => Err(Error::NotFound), + Some(FdEntry::Dir(_)) => Err(Error::BadFileDescriptor), + None => Err(Error::BadFileDescriptor), } } - fn put_file(&mut self, fd: Fd, file: File) { + pub(crate) fn put_file(&mut self, fd: Fd, file: File) { self.fd_table.update(fd, FdEntry::File(file)) } - fn get_dir(&self, fd: Fd) -> Result { + pub(crate) fn get_dir(&self, fd: Fd) -> Result { match self.fd_table.get(fd) { Some(FdEntry::Dir(dir)) => Ok(dir.clone()), - Some(FdEntry::File(_)) => Err(Error::InvalidFileType), - None => Err(Error::NotFound), + Some(FdEntry::File(_)) => Err(Error::BadFileDescriptor), + None => Err(Error::BadFileDescriptor), } } @@ -121,7 +186,7 @@ impl FileSystem { memory: Box, ) -> Result<(), Error> { // create a file for the mount - let fd = self.open_or_create( + let fd = self.open( self.root_fd, filename, FdStat::default(), @@ -129,18 +194,20 @@ impl FileSystem { 0, )?; - let node = self.get_node(fd)?; - self.close(fd)?; + let result = (|| { + let file = self.get_file(fd)?; + self.storage.mount_node(file.node, memory) + })(); - self.storage.mount_node(node, memory)?; + let _ = self.close(fd); - Ok(()) + result } // initialize mounted memory with the data stored in the host file pub fn init_memory_file(&mut self, filename: &str) -> Result<(), Error> { // create a file for the mount - let fd = self.open_or_create( + let fd = self.open( self.root_fd, filename, FdStat::default(), @@ -148,16 +215,20 @@ impl FileSystem { 0, )?; - let node = self.get_node(fd)?; - self.close(fd)?; + let result = (|| { + let file = self.get_file(fd)?; + self.storage.init_mounted_memory(file.node) + })(); - self.storage.init_mounted_memory(node) + let _ = self.close(fd); + + result } // store content of the currently active memory file to the file system pub fn store_memory_file(&mut self, filename: &str) -> Result<(), Error> { // create a file for the mount - let fd = self.open_or_create( + let fd = self.open( self.root_fd, filename, FdStat::default(), @@ -165,16 +236,20 @@ impl FileSystem { 0, )?; - let node = self.get_node(fd)?; - self.close(fd)?; + let result = (|| { + let file = self.get_file(fd)?; + self.storage.store_mounted_memory(file.node) + })(); - self.storage.store_mounted_memory(node) + let _ = self.close(fd); + + result } // Unmount memory, the system will continue to work with the file in normal mode. pub fn unmount_memory_file(&mut self, filename: &str) -> Result, Error> { // create a file for the mount - let fd = self.open_or_create( + let fd = self.open( self.root_fd, filename, FdStat::default(), @@ -182,12 +257,17 @@ impl FileSystem { 0, )?; - let node = self.get_node(fd)?; - self.close(fd)?; + let result = (|| { + let file = self.get_file(fd)?; - let memory = self.storage.unmount_node(node)?; + let memory = self.storage.unmount_node(file.node)?; - Ok(memory) + Ok(memory) + })(); + + let _ = self.close(fd); + + result } // Get directory entry for a given directory file descriptor and the entry index. @@ -195,6 +275,10 @@ impl FileSystem { self.get_dir(fd)?.get_entry(index, self.storage.as_ref()) } + fn get_node_direntry(&self, node: Node, index: DirEntryIndex) -> Result { + self.storage.get_direntry(node, index) + } + fn put_dir(&mut self, fd: Fd, dir: Dir) { self.fd_table.update(fd, FdEntry::Dir(dir)) } @@ -297,15 +381,7 @@ impl FileSystem { Ok(pos) } - // Close the opened file and release the corresponding file descriptor. - pub fn close(&mut self, fd: Fd) -> Result<(), Error> { - self.flush(fd)?; - self.fd_table.close(fd).ok_or(Error::NotFound)?; - - Ok(()) - } - - // Get the metadata for a given file descriptor + // Get the metadata for a given node pub fn metadata_from_node(&self, node: Node) -> Result { self.storage.get_metadata(node) } @@ -316,10 +392,36 @@ impl FileSystem { self.storage.get_metadata(node) } - // update metadata of a given file descriptor + // Update metadata of a given file descriptor pub fn set_metadata(&mut self, fd: Fd, metadata: Metadata) -> Result<(), Error> { let node = self.get_node(fd)?; - self.storage.put_metadata(node, metadata); + self.storage.put_metadata(node, &metadata)?; + + Ok(()) + } + + pub fn set_file_size(&mut self, fd: Fd, new_size: FileSize) -> Result<(), Error> { + let file = self.get_file(fd)?; + + let mut metadata = self.storage.get_metadata(file.node)?; + + metadata.size = new_size; + + self.storage.put_metadata(file.node, &metadata)?; + + Ok(()) + } + + // Set maxmum file size limit in bytes. Reading, writing, and setting the cursor above the limit will result in error. + // Use this feature to limit how much memory can be consumed by the mounted memory files. + pub fn set_file_size_limit(&mut self, fd: Fd, max_size: FileSize) -> Result<(), Error> { + let file = self.get_file(fd)?; + + let mut metadata = self.storage.get_metadata(file.node)?; + + metadata.maximum_size_allowed = Some(max_size); + + self.storage.put_metadata(file.node, &metadata)?; Ok(()) } @@ -331,7 +433,7 @@ impl FileSystem { metadata.times.accessed = time; - self.storage.put_metadata(node, metadata); + self.storage.put_metadata(node, &metadata)?; Ok(()) } @@ -343,7 +445,7 @@ impl FileSystem { metadata.times.modified = time; - self.storage.put_metadata(node, metadata); + self.storage.put_metadata(node, &metadata)?; Ok(()) } @@ -351,7 +453,7 @@ impl FileSystem { // Get file or directory stats. pub fn get_stat(&self, fd: Fd) -> Result<(FileType, FdStat), Error> { match self.fd_table.get(fd) { - None => Err(Error::NotFound), + None => Err(Error::BadFileDescriptor), Some(FdEntry::File(file)) => Ok((FileType::RegularFile, file.stat)), Some(FdEntry::Dir(dir)) => Ok((FileType::Directory, dir.stat)), } @@ -367,12 +469,17 @@ impl FileSystem { Ok(()) } Some(FdEntry::Dir(dir)) => { + // file-only stats cause badfd error + if stat.flags.contains(FdFlags::APPEND) || stat.flags.contains(FdFlags::NONBLOCK) { + return Err(Error::BadFileDescriptor); + } + let mut dir = dir.clone(); dir.stat = stat; self.put_dir(fd, dir); Ok(()) } - None => Err(Error::NotFound), + None => Err(Error::BadFileDescriptor), } } @@ -383,40 +490,39 @@ impl FileSystem { self.storage.get_metadata(node) } - // Opens of creates a new file. - pub fn open_or_create( + // Opens a directory or file or creates a new file (depending on the flags provided). + pub fn open( &mut self, - parent: Fd, + parent_fd: Fd, path: &str, stat: FdStat, flags: OpenFlags, ctime: u64, ) -> Result { - let dir = self.get_dir(parent)?; + let dir = self.get_dir(parent_fd)?; match find_node(dir.node, path, &mut self.names_cache, self.storage.as_ref()) { - Ok(node) => self.open(node, stat, flags), - Err(Error::NotFound) => { + Ok(node) => self.open_internal(node, stat, flags), + + Err(Error::BadFileDescriptor) => { if !flags.contains(OpenFlags::CREATE) { - return Err(Error::NotFound); + return Err(Error::BadFileDescriptor); } if flags.contains(OpenFlags::DIRECTORY) { - return Err(Error::InvalidFileType); + self.create_open_directory(parent_fd, path, stat, ctime) + } else { + self.create_open_file(parent_fd, path, stat, ctime) } - - self.create_file(parent, path, stat, ctime) } Err(err) => Err(err), } } - // Opens a file and returns its new file descriptor. - fn open(&mut self, node: Node, stat: FdStat, flags: OpenFlags) -> Result { - if flags.contains(OpenFlags::EXCLUSIVE) { - return Err(Error::FileAlreadyExists); - } + // Opens an existing file or directory by node and return its new file descriptor. + fn open_internal(&mut self, node: Node, stat: FdStat, flags: OpenFlags) -> Result { let metadata = self.storage.get_metadata(node)?; + match metadata.file_type { FileType::Directory => { let dir = Dir::new(node, stat, self.storage.as_mut())?; @@ -425,21 +531,24 @@ impl FileSystem { } FileType::RegularFile => { if flags.contains(OpenFlags::DIRECTORY) { - return Err(Error::InvalidFileType); + return Err(Error::InvalidArgument); } + let file = File::new(node, stat, self.storage.as_mut())?; + if flags.contains(OpenFlags::TRUNCATE) { file.truncate(self.storage.as_mut())?; } + let fd = self.fd_table.open(FdEntry::File(file)); Ok(fd) } - FileType::SymbolicLink => unimplemented!("Symbolic links are not supported yet"), + FileType::SymbolicLink => unimplemented!("Symbolic links are not supported"), } } - // Create a new file named `path` in the given `parent` folder. - pub fn create_file( + // Create a new file and open it. Function fails if the file exists already. + pub(crate) fn create_open_file( &mut self, parent: Fd, path: &str, @@ -458,6 +567,7 @@ impl FileSystem { let child_fd = self.fd_table.open(FdEntry::File(child)); self.put_dir(parent, dir); + Ok(child_fd) } @@ -469,11 +579,32 @@ impl FileSystem { self.fd_table.node_refcount(), &mut self.names_cache, self.storage.as_mut(), - ) + )?; + + self.put_dir(parent, dir); + + Ok(()) + } + + // Convenience method, create a new directory without opening it + pub fn mkdir(&mut self, parent: Fd, path: &str, stat: FdStat, ctime: u64) -> Result<(), Error> { + let dir = self.get_dir(parent)?; + + dir.create_dir( + path, + stat, + &mut self.names_cache, + self.storage.as_mut(), + ctime, + )?; + + self.put_dir(parent, dir); + + Ok(()) } - // Create a new directory named `path` in the given `parent` folder. - pub fn create_dir( + // create a directory and return an opened file descriptor of it + pub fn create_open_directory( &mut self, parent: Fd, path: &str, @@ -481,6 +612,7 @@ impl FileSystem { ctime: u64, ) -> Result { let dir = self.get_dir(parent)?; + let child = dir.create_dir( path, stat, @@ -488,8 +620,10 @@ impl FileSystem { self.storage.as_mut(), ctime, )?; + let child_fd = self.fd_table.open(FdEntry::Dir(child)); self.put_dir(parent, dir); + Ok(child_fd) } @@ -501,7 +635,94 @@ impl FileSystem { self.fd_table.node_refcount(), &mut self.names_cache, self.storage.as_mut(), - ) + )?; + + self.put_dir(parent, dir); + + Ok(()) + } + + pub(crate) fn list_dir_internal( + &mut self, + dir_fd: Fd, + file_type: Option, + ) -> Result, Error> { + let mut res = vec![]; + + let meta = self.metadata(dir_fd)?; + + let mut entry_index = meta.first_dir_entry; + + while let Some(index) = entry_index { + let entry = self.get_node_direntry(meta.node, index)?; + + // here we assume the entry value name is correct UTF-8 + let filename = unsafe { + std::str::from_utf8_unchecked(&entry.name.bytes[..(entry.name.length as usize)]) + } + .to_string(); + + if let Some(file_type) = file_type { + let meta = self.metadata_from_node(entry.node)?; + + if meta.file_type == file_type { + res.push((entry.node, filename)); + } + } else { + res.push((entry.node, filename)); + } + + entry_index = entry.next_entry; + } + + Ok(res) + } + + /// A convenience method to recursively remove a directory (and all subdirectories/files within) or delete a file, if the entry is a file. + pub fn remove_recursive(&mut self, parent: Fd, path: &str) -> Result<(), Error> { + let meta = self.open_metadata(parent, path)?; + + if meta.file_type == FileType::RegularFile { + return self.remove_file(parent, path); + } + + // Open the target directory. We use `OpenFlags::DIRECTORY` to ensure + // the path is interpreted as a directory (or fail if it doesn't exist). + let dir_fd = self.open(parent, path, FdStat::default(), OpenFlags::DIRECTORY, 0)?; + + let result = (|| { + // Find all directory children + let children = self.list_dir_internal(dir_fd, None)?; + + // For each child, figure out if it's a subdirectory or file and remove accordingly. + for (child_node, child_name) in children { + let child_meta = self.storage.get_metadata(child_node)?; + + match child_meta.file_type { + FileType::Directory => { + // Recurse into the subdirectory. + self.remove_recursive(dir_fd, &child_name)?; + } + FileType::RegularFile => { + // Remove the file. + self.remove_file(dir_fd, &child_name)?; + } + FileType::SymbolicLink => { + unimplemented!("Symbolic links are not supported yet"); + } + } + } + + Ok(()) + })(); + + // close the folder itself before its deletion + self.close(dir_fd)?; + + // Now that it is empty, remove the directory entry from its parent. + self.remove_dir(parent, path)?; + + result } // Create a hard link to an existing file. @@ -532,7 +753,7 @@ impl FileSystem { self.storage.as_ref(), )?; - self.open(node, FdStat::default(), OpenFlags::empty()) + self.open_internal(node, FdStat::default(), OpenFlags::empty()) } // Rename a file. @@ -567,7 +788,7 @@ impl FileSystem { self.storage.as_mut(), )?; - self.open(node, FdStat::default(), OpenFlags::empty()) + self.open_internal(node, FdStat::default(), OpenFlags::empty()) } #[cfg(test)] @@ -580,1162 +801,3 @@ impl FileSystem { self.get_file(fd).unwrap() } } - -#[cfg(test)] -mod tests { - - use ic_stable_structures::memory_manager::{MemoryId, MemoryManager}; - use ic_stable_structures::{Memory, VectorMemory}; - - use crate::test_utils::write_text_at_offset; - use crate::{ - error::Error, - fs::{DstBuf, FdFlags, SrcBuf}, - runtime::{ - structure_helpers::find_node, - types::{FdStat, OpenFlags}, - }, - storage::{ - stable::StableStorage, - types::{FileSize, FileType}, - }, - test_utils::{ - new_vector_memory, read_text_file, test_fs, test_fs_setups, test_fs_transient, - write_text_fd, write_text_file, - }, - }; - - use super::{Fd, FileSystem}; - - pub fn list_files(fs: &mut FileSystem, path: &str) -> Vec { - use std::str::FromStr; - - let mut res = vec![]; - - let dir = fs.root_fd(); - - let fd = fs - .open_or_create(dir, path, FdStat::default(), OpenFlags::DIRECTORY, 0) - .unwrap(); - - let meta = fs.metadata(fd).unwrap(); - - let mut entry_index = meta.first_dir_entry; - - while let Some(index) = entry_index { - let entry = fs.get_direntry(fd, index).unwrap(); - - let filename_str: &str = - std::str::from_utf8(&entry.name.bytes[0..(entry.name.length as usize)]).unwrap(); - - let st = String::from_str(filename_str).unwrap(); - - res.push(st); - - entry_index = entry.next_entry; - } - - res - } - - #[test] - fn get_root_info() { - let fs = test_fs(); - - let fd = fs.root_fd(); - let path = fs.root_path(); - - assert!(fd == 3); - assert!(path == "/"); - } - - #[test] - fn create_file() { - let mut fs = test_fs(); - - let file = fs - .create_file(fs.root_fd(), "test.txt", Default::default(), 0) - .unwrap(); - - assert!(file > fs.root_fd()); - } - - #[test] - fn create_dir() { - let mut fs = test_fs(); - - let dir = fs - .create_dir(fs.root_fd(), "test", FdStat::default(), 0) - .unwrap(); - - let fd = fs - .create_file(dir, "file.txt", FdStat::default(), 0) - .unwrap(); - fs.write(fd, "Hello, world!".as_bytes()).unwrap(); - - let dir = fs - .open_or_create( - fs.root_fd(), - "test", - FdStat::default(), - OpenFlags::empty(), - 0, - ) - .unwrap(); - - let fd = fs - .open_or_create(dir, "file.txt", FdStat::default(), OpenFlags::empty(), 0) - .unwrap(); - - let mut buf = [0; 13]; - fs.read(fd, &mut buf).unwrap(); - assert_eq!(&buf, "Hello, world!".as_bytes()); - } - - #[test] - fn create_file_creates_a_few_files() { - let mut fs = test_fs(); - - let dir = fs.root_fd(); - - fs.create_file(dir, "test1.txt", FdStat::default(), 0) - .unwrap(); - fs.create_file(dir, "test2.txt", FdStat::default(), 0) - .unwrap(); - fs.create_file(dir, "test3.txt", FdStat::default(), 0) - .unwrap(); - - let meta = fs.metadata(fs.root_fd()).unwrap(); - - let entry_index = meta.first_dir_entry.unwrap(); - - let entry1 = fs.get_direntry(fs.root_fd(), entry_index).unwrap(); - let entry2 = fs.get_direntry(fs.root_fd(), entry_index + 1).unwrap(); - let entry3 = fs.get_direntry(fs.root_fd(), entry_index + 2).unwrap(); - - assert_eq!(entry1.prev_entry, None); - assert_eq!(entry1.next_entry, Some(entry_index + 1)); - - assert_eq!(entry2.prev_entry, Some(entry_index)); - assert_eq!(entry2.next_entry, Some(entry_index + 2)); - - assert_eq!(entry3.prev_entry, Some(entry_index + 1)); - assert_eq!(entry3.next_entry, None); - } - - #[test] - fn close_file_fd_reused() { - let mut fs = test_fs(); - - let dir = fs.root_fd(); - - fs.create_file(dir, "test1.txt", FdStat::default(), 0) - .unwrap(); - let fd2 = fs - .create_file(dir, "test2.txt", FdStat::default(), 0) - .unwrap(); - fs.create_file(dir, "test3.txt", FdStat::default(), 0) - .unwrap(); - - fs.close(fd2).unwrap(); - - let fd4 = fs - .create_file(dir, "test4.txt", FdStat::default(), 0) - .unwrap(); - - assert_eq!(fd2, fd4); - } - - #[test] - fn fd_renumber() { - let mut fs = test_fs(); - - let dir = fs.root_fd(); - - let fd1 = fs - .create_file(dir, "test1.txt", FdStat::default(), 0) - .unwrap(); - let fd2 = fs - .create_file(dir, "test2.txt", FdStat::default(), 0) - .unwrap(); - - let entry1 = fs.get_node(fd1); - - fs.renumber(fd1, fd2).unwrap(); - - assert!(fs.get_node(fd1).is_err()); - assert_eq!(fs.get_node(fd2), entry1); - } - - #[test] - fn seek_and_write() { - let mut fs = test_fs(); - - let dir = fs.root_fd(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.seek(fd, 24, super::Whence::SET).unwrap(); - - fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); - - let meta = fs.metadata(fd).unwrap(); - - assert_eq!(meta.size, 29); - - fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); - let mut buf = [42u8; 29]; - let rr = fs.read(fd, &mut buf).unwrap(); - assert_eq!(rr, 29); - assert_eq!( - buf, - [ - 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, - 4, 5 - ] - ); - - fs.close(fd).unwrap(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - let mut buf = [42u8; 29]; - let rr = fs.read(fd, &mut buf).unwrap(); - assert_eq!(rr, 29); - assert_eq!( - buf, - [ - 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, - 4, 5 - ] - ); - - fs.close(fd).unwrap(); - } - - #[test] - fn read_and_write_vec() { - let mut fs = test_fs(); - - let dir = fs.root_fd(); - - let write_content1 = "This is a sample file content."; - let write_content2 = "1234567890"; - - let write_content = [ - SrcBuf { - buf: write_content1.as_ptr(), - len: write_content1.len(), - }, - SrcBuf { - buf: write_content2.as_ptr(), - len: write_content2.len(), - }, - ]; - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.write_vec(fd, write_content.as_ref()).unwrap(); - - let meta = fs.metadata(fd).unwrap(); - assert_eq!(meta.size, 40); - - fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); - - let mut read_content1 = String::from("......................"); - let mut read_content2 = String::from("......................"); - - let read_content = [ - DstBuf { - buf: read_content1.as_mut_ptr(), - len: read_content1.len(), - }, - DstBuf { - buf: read_content2.as_mut_ptr(), - len: read_content2.len(), - }, - ]; - - fs.read_vec(fd, &read_content).unwrap(); - - assert_eq!("This is a sample file ", read_content1); - assert_eq!("content.1234567890....", read_content2); - - fs.close(fd).unwrap(); - } - - #[test] - fn read_and_write_vec_with_offset() { - let mut fs = test_fs(); - - let dir = fs.root_fd(); - - let write_content1 = "This is a sample file content."; - let write_content2 = "1234567890"; - - let write_content = [ - SrcBuf { - buf: write_content1.as_ptr(), - len: write_content1.len(), - }, - SrcBuf { - buf: write_content2.as_ptr(), - len: write_content2.len(), - }, - ]; - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.write_vec_with_offset(fd, write_content.as_ref(), 2) - .unwrap(); - - let meta = fs.metadata(fd).unwrap(); - assert_eq!(meta.size, 42); - - fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); - - let mut read_content1 = String::from("......................"); - let mut read_content2 = String::from("......................"); - - let read_content = [ - DstBuf { - buf: read_content1.as_mut_ptr(), - len: read_content1.len(), - }, - DstBuf { - buf: read_content2.as_mut_ptr(), - len: read_content2.len(), - }, - ]; - - fs.read_vec_with_offset(fd, &read_content, 1).unwrap(); - - assert_eq!("\0This is a sample file", read_content1); - assert_eq!(" content.1234567890...", read_content2); - - fs.close(fd).unwrap(); - } - - #[test] - fn seek_and_write_transient() { - let mut fs = test_fs_transient(); - - let dir = fs.root_fd(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.seek(fd, 24, super::Whence::SET).unwrap(); - - fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); - - let meta = fs.metadata(fd).unwrap(); - - assert_eq!(meta.size, 29); - - fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); - let mut buf = [42u8; 29]; - let rr = fs.read(fd, &mut buf).unwrap(); - assert_eq!(rr, 29); - assert_eq!( - buf, - [ - 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, - 4, 5 - ] - ); - - fs.close(fd).unwrap(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - let mut buf = [42u8; 29]; - let rr = fs.read(fd, &mut buf).unwrap(); - assert_eq!(rr, 29); - assert_eq!( - buf, - [ - 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, - 4, 5 - ] - ); - - fs.close(fd).unwrap(); - } - - #[test] - fn create_and_remove_file() { - for mut fs in test_fs_setups("virtual_memory.txt") { - let dir = fs.root_fd(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); - fs.close(fd).unwrap(); - - fs.remove_file(dir, "test.txt").unwrap(); - - let err = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::empty(), 0) - .unwrap_err(); - assert_eq!(err, Error::NotFound); - } - } - - #[test] - fn cannot_remove_opened_file() { - for mut fs in test_fs_setups("virtual_memory.txt") { - let dir = fs.root_fd(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); - - let err = fs.remove_file(dir, "test.txt").unwrap_err(); - assert_eq!(err, Error::CannotRemoveOpenedNode); - - fs.close(fd).unwrap(); - fs.remove_file(dir, "test.txt").unwrap(); - } - } - - #[test] - fn cannot_remove_directory_as_file() { - for mut fs in test_fs_setups("virtual_memory.txt") { - let dir = fs.root_fd(); - - let fd = fs.create_dir(dir, "test", FdStat::default(), 0).unwrap(); - fs.close(fd).unwrap(); - - let err = fs.remove_file(dir, "test").unwrap_err(); - assert_eq!(err, Error::ExpectedToRemoveFile); - - fs.remove_dir(dir, "test").unwrap(); - } - } - - #[test] - fn cannot_remove_file_as_directory() { - for mut fs in test_fs_setups("virtual_memory.txt") { - let dir = fs.root_fd(); - - let fd = fs - .open_or_create(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - fs.close(fd).unwrap(); - - let err = fs.remove_dir(dir, "test.txt").unwrap_err(); - assert_eq!(err, Error::ExpectedToRemoveDirectory); - - fs.remove_file(dir, "test.txt").unwrap(); - } - } - - #[test] - fn renumber_when_the_alternative_file_exists() { - for mut fs in test_fs_setups("virtual_memory.txt") { - let dir = fs.root_fd(); - - let fd1 = fs - .open_or_create(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); - - let pos1 = fs.tell(fd1).unwrap(); - - let fd2 = fs - .open_or_create(dir, "file2.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - let pos2 = fs.tell(fd2).unwrap(); - - assert!(pos1 == 5); - assert!(pos2 == 0); - - fs.renumber(fd1, fd2).unwrap(); - - let pos2_renumbered = fs.tell(fd2).unwrap(); - - assert!(pos1 == pos2_renumbered); - - let res = fs.tell(fd1); - - assert!(res.is_err()); - } - } - - #[test] - fn renumber_when_the_alternative_file_doesnt_exist() { - for mut fs in test_fs_setups("file1.txt") { - let dir = fs.root_fd(); - - let fd1 = fs - .open_or_create(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); - - let pos1 = fs.tell(fd1).unwrap(); - - assert!(pos1 == 5); - - let fd2 = 100; - - fs.renumber(fd1, fd2).unwrap(); - - let pos2_renumbered = fs.tell(fd2).unwrap(); - - assert!(pos1 == pos2_renumbered); - - let res = fs.tell(fd1); - - assert!(res.is_err()); - } - } - - #[test] - fn set_modified_set_accessed_time() { - for mut fs in test_fs_setups("") { - let dir = fs.root_fd(); - - let fd1 = fs - .open_or_create(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 111) - .unwrap(); - - fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); - - fs.set_accessed_time(fd1, 333).unwrap(); - fs.set_modified_time(fd1, 222).unwrap(); - - let metadata = fs.metadata(fd1).unwrap(); - - let times = metadata.times; - - assert_eq!(times.accessed, 333); - assert_eq!(times.modified, 222); - assert_eq!(times.created, 111); - - assert_eq!(metadata.size, 5); - assert_eq!(metadata.file_type, FileType::RegularFile); - } - } - - #[test] - fn set_stat_get_stat() { - let mut fs = test_fs(); - let dir = fs.root_fd(); - - let fd1 = fs - .open_or_create(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 111) - .unwrap(); - - fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); - - let (file_type, mut stat) = fs.get_stat(fd1).unwrap(); - - assert_eq!(file_type, FileType::RegularFile); - - assert_eq!(stat.flags, FdFlags::empty()); - - stat.flags = FdFlags::APPEND; - - fs.set_stat(fd1, stat).unwrap(); - - let (_, stat2) = fs.get_stat(fd1).unwrap(); - - assert_eq!(stat2.flags, FdFlags::APPEND); - } - - fn create_test_file_with_content( - fs: &mut FileSystem, - parent: Fd, - file_name: &str, - content: Vec, - ) -> Fd { - let file_fd = fs - .create_file(parent, file_name, FdStat::default(), 0) - .unwrap(); - - let mut src = String::from(""); - - for str in content.iter() { - src.push_str(str.as_str()); - } - - let bytes_written = fs.write(file_fd, src.as_bytes()).unwrap(); - - assert!(bytes_written > 0); - - file_fd as Fd - } - - fn create_test_file(fs: &mut FileSystem, parent_fd: Fd, file_name: &str) -> Fd { - create_test_file_with_content( - fs, - parent_fd, - file_name, - vec![ - String::from("This is a sample text."), - String::from("1234567890"), - ], - ) - } - - #[test] - fn link_seek_tell() { - let mut fs = test_fs(); - let dir = fs.root_fd(); - - let root_fd = 3i32; - - let file_name1 = String::from("file.txt"); - let file_name2 = String::from("file_link.txt"); - - let file_fd = create_test_file(&mut fs, root_fd as Fd, &file_name1); - - let root_node = fs.storage.as_ref().root_node(); - let node1 = find_node( - root_node, - &file_name1, - &mut fs.names_cache, - fs.storage.as_ref(), - ) - .unwrap(); - - // test seek and tell - let position = fs.tell(file_fd).unwrap(); - - assert_eq!(position, 32); - - fs.seek(file_fd, 10, crate::fs::Whence::SET).unwrap(); - - let position_after_seek = fs.tell(file_fd).unwrap(); - - assert_eq!(position_after_seek, 10); - - let mut buf_to_read1 = String::from("..............."); - - let bytes_read = fs - .read(file_fd, unsafe { buf_to_read1.as_bytes_mut() }) - .unwrap(); - - assert_eq!(bytes_read, 15); - assert_eq!(buf_to_read1, "sample text.123"); - - // create link - fs.create_hard_link(dir, &file_name1, dir, &file_name2) - .unwrap(); - - let node2 = find_node( - root_node, - &file_name2, - &mut fs.names_cache, - fs.storage.as_ref(), - ) - .unwrap(); - - assert_eq!(node1, node2); - - let link_file_fd = fs - .open_or_create( - dir, - "file_link.txt", - FdStat::default(), - OpenFlags::empty(), - 0, - ) - .unwrap(); - - fs.seek(link_file_fd, 10, crate::fs::Whence::SET).unwrap(); - - let position_link = fs.tell(link_file_fd).unwrap(); - - assert_eq!(position_link, 10); - - let mut buf_to_read1 = String::from("................"); - - let bytes_read = fs - .read(link_file_fd, unsafe { buf_to_read1.as_bytes_mut() }) - .unwrap(); - - assert_eq!(bytes_read, 16); - - assert_eq!(buf_to_read1, "sample text.1234"); - } - - #[test] - fn renaming_folder_with_contents() { - let mut fs = test_fs(); - let root_fd = fs.root_fd(); - - let file_name = String::from("dir1/dir2/file.txt"); - create_test_file(&mut fs, root_fd as Fd, &file_name); - - fs.rename(root_fd, "dir1/dir2", root_fd, "dir2").unwrap(); - - let file_fd = fs - .open_or_create( - root_fd, - "dir2/file.txt", - FdStat::default(), - OpenFlags::empty(), - 0, - ) - .unwrap(); - - fs.seek(file_fd, 10, crate::fs::Whence::SET).unwrap(); - - let mut buf_to_read1 = String::from("................"); - - let bytes_read = fs - .read(file_fd, unsafe { buf_to_read1.as_bytes_mut() }) - .unwrap(); - - assert_eq!(bytes_read, 16); - - assert_eq!(buf_to_read1, "sample text.1234"); - } - - #[test] - fn write_and_read_25_files() { - for mut fs in test_fs_setups("auto/my_file_6.txt") { - let root_fd = fs.root_fd(); - const SIZE_OF_FILE: usize = 1_000_000; - - // write files - let dir_name = "auto"; - let file_count: u8 = 25; - - for i in 0..file_count { - let filename = format!("{}/my_file_{}.txt", dir_name, i); - let content = format!("{i}"); - let times = SIZE_OF_FILE / content.len(); - - write_text_file(&mut fs, root_fd, filename.as_str(), content.as_str(), times) - .unwrap(); - } - - // read files - for i in 0..file_count { - let filename = format!("{}/my_file_{}.txt", dir_name, i); - let expected_content = format!("{i}{i}{i}"); - - let text_read = read_text_file( - &mut fs, - root_fd, - filename.as_str(), - 0, - expected_content.len(), - ); - - assert_eq!(expected_content, text_read); - } - } - - // This test should not crash with an error - } - - #[test] - fn empty_path_support() { - let mut fs = test_fs(); - let root_fd = fs.root_fd(); - - write_text_file(&mut fs, root_fd, "f1/f2/text.txt", "content123", 100).unwrap(); - - let content = read_text_file(&mut fs, root_fd, "f1/f2/text.txt", 7, 10); - assert_eq!(content, "123content"); - - let content = read_text_file(&mut fs, root_fd, "f1//f2/text.txt", 6, 10); - assert_eq!(content, "t123conten"); - - let content = read_text_file(&mut fs, root_fd, "/f1//f2/text.txt", 5, 10); - assert_eq!(content, "nt123conte"); - - write_text_file(&mut fs, root_fd, "text.txt", "abc", 100).unwrap(); - - let content = read_text_file(&mut fs, root_fd, "text.txt", 0, 6); - assert_eq!(content, "abcabc"); - - let content = read_text_file(&mut fs, root_fd, "/text.txt", 0, 6); - assert_eq!(content, "abcabc"); - - let content = read_text_file(&mut fs, root_fd, "///////text.txt", 0, 6); - assert_eq!(content, "abcabc"); - - // This test should not crash with an error - } - - #[test] - fn writing_into_mounted_memory() { - let memory: VectorMemory = new_vector_memory(); - - let mut fs = test_fs(); - - let root_fd = fs.root_fd(); - - fs.mount_memory_file("test.txt", Box::new(memory.clone())) - .unwrap(); - - let content = "ABCDEFG123"; - - write_text_file(&mut fs, root_fd, "test.txt", content, 1).unwrap(); - - let mut buf = [0u8; 100]; - - memory.read(0, &mut buf); - - println!("{:?}", buf); - } - - #[test] - fn reading_mounted_memory_after_upgrade() { - let memory_manager = MemoryManager::init(new_vector_memory()); - let memory = memory_manager.get(MemoryId::new(1)); - - let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210); - let mut fs = FileSystem::new(Box::new(storage)).unwrap(); - fs.mount_memory_file("test.txt", Box::new(memory.clone())) - .unwrap(); - - let root_fd = fs.root_fd(); - let content = "ABCDEFG123"; - write_text_file(&mut fs, root_fd, "test.txt", content, 2).unwrap(); - - // imitate canister upgrade (we keep the memory manager but recreate the file system with the same virtual memories) - let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210); - let mut fs = FileSystem::new(Box::new(storage)).unwrap(); - fs.mount_memory_file("test.txt", Box::new(memory.clone())) - .unwrap(); - let root_fd = fs.root_fd(); - - let content = read_text_file(&mut fs, root_fd, "test.txt", 0, 100); - - assert_eq!(content, "ABCDEFG123ABCDEFG123"); - } - - #[test] - fn deleting_mounted_file_fails() { - let memory: VectorMemory = new_vector_memory(); - - let mut fs = test_fs(); - - let root_fd = fs.root_fd(); - - fs.mount_memory_file("test.txt", Box::new(memory.clone())) - .unwrap(); - - let res = fs.remove_file(root_fd, "test.txt"); - - assert!( - res == Err(Error::CannotRemoveMountedMemoryFile), - "Deleting a mounted file should not be allowed!" - ); - - // check the dir entry still exists after deletion - let files = list_files(&mut fs, ""); - - assert_eq!(files[0], "test.txt".to_string()); - } - - #[test] - fn mounted_memory_store_and_init_roundtrip() { - for mut fs in test_fs_setups("") { - let memory1: VectorMemory = new_vector_memory(); - let memory2: VectorMemory = new_vector_memory(); - - let file_name = "test.txt"; - - fs.mount_memory_file(file_name, Box::new(memory1.clone())) - .unwrap(); - - let content = "ABCDEFG123"; - let len = content.len(); - let count = 1000; - - memory1.grow(5); - - // fill up memory with some data - for i in 0..count { - memory1.write(i as u64 * len as u64, content.as_bytes()); - } - - let fd = fs - .open_or_create( - fs.root_fd, - file_name, - FdStat::default(), - OpenFlags::empty(), - 0, - ) - .unwrap(); - let mut metadata = fs.metadata(fd).unwrap(); - metadata.size = len as FileSize * count as FileSize; - fs.set_metadata(fd, metadata).unwrap(); - fs.close(fd).unwrap(); - - // store memory into a file - fs.store_memory_file(file_name).unwrap(); - - fs.unmount_memory_file(file_name).unwrap(); - - fs.mount_memory_file(file_name, Box::new(memory2.clone())) - .unwrap(); - - // init new memory into a file - fs.init_memory_file(file_name).unwrap(); - - let mut buf1 = [0u8; 10]; - let mut buf2 = [0u8; 10]; - - for i in 0..count { - memory1.read(i as u64 * len as u64, &mut buf1); - memory2.read(i as u64 * len as u64, &mut buf2); - - assert_eq!(buf1, buf2); - } - } - } - - #[test] - fn writing_from_different_file_descriptors() { - for mut fs in test_fs_setups("f1/f2/text.txt") { - let root_fd = fs.root_fd(); - - let fd1 = fs - .open_or_create( - root_fd, - "f1/f2/text.txt", - FdStat::default(), - OpenFlags::CREATE, - 40, - ) - .unwrap(); - let fd2 = fs - .open_or_create( - root_fd, - "f1//f2/text.txt", - FdStat::default(), - OpenFlags::CREATE, - 44, - ) - .unwrap(); - - write_text_fd(&mut fs, fd1, "abc", 1).unwrap(); - write_text_fd(&mut fs, fd2, "123", 1).unwrap(); - write_text_fd(&mut fs, fd1, "xyz", 1).unwrap(); - - let content = read_text_file(&mut fs, root_fd, "/f1/f2/text.txt", 0, 9); - - assert_eq!("123xyz", content); - } - } - - #[test] - fn write_into_empty_filename_fails() { - for mut fs in test_fs_setups("") { - let root_fd = fs.root_fd(); - let res = write_text_file(&mut fs, root_fd, "", "content123", 100); - assert!(res.is_err()); - } - } - - fn create_file_with_size(filename: &str, size: FileSize, fs: &mut FileSystem) -> Fd { - let fd = fs - .open_or_create( - fs.root_fd, - filename, - FdStat::default(), - OpenFlags::CREATE, - 12, - ) - .unwrap(); - let mut meta = fs.metadata(fd).unwrap(); - meta.size = size; - - fs.set_metadata(fd, meta).unwrap(); - - fd - } - - // test sparse files - #[test] - fn set_size_for_an_empty_file() { - let filename = "test.txt"; - - for mut fs in test_fs_setups(filename) { - let root_fd = fs.root_fd(); - let fd = create_file_with_size(filename, 15, &mut fs); - - let content = read_text_file(&mut fs, root_fd, filename, 0, 100); - - assert_eq!(content, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); - - write_text_at_offset(&mut fs, fd, "abc", 3, 3).unwrap(); - - let content = read_text_file(&mut fs, root_fd, filename, 1, 100); - - assert_eq!(content, "\0\0abcabcabc\0\0\0"); - } - } - - #[test] - fn create_file_missing_chunk_in_the_middle() { - let filename = "test.txt"; - - for mut fs in test_fs_setups(filename) { - let chunk_size = fs.storage.chunk_size(); - - let root_fd = fs.root_fd(); - let fd = create_file_with_size(filename, chunk_size as FileSize * 2 + 500, &mut fs); - - let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); - - let vec = vec![0; chunk_size * 2 + 500]; - let expected = String::from_utf8(vec).unwrap(); - - // expect all zeroes at first - assert_eq!(content, expected); - - // write some text to the first chunk - write_text_at_offset(&mut fs, fd, "abc", 33, 3).unwrap(); - - // write some text to the 100th position of the third chunk - write_text_at_offset(&mut fs, fd, "abc", 33, chunk_size as FileSize * 2 + 100).unwrap(); - - // read what we have now - let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); - - let mut expected = vec![0u8; chunk_size * 2 + 500]; - - let pattern = b"abc".repeat(33); - expected[3..3 + 99].copy_from_slice(&pattern[..]); - expected[chunk_size * 2 + 100..chunk_size * 2 + 100 + 99].copy_from_slice(&pattern[..]); - - let expected = String::from_utf8(expected).unwrap(); - - assert_eq!(content, expected); - } - } - - #[test] - fn iterate_file_only_middle_chunk_is_present() { - let filename = "test.txt"; - - for mut fs in test_fs_setups(filename) { - let chunk_size = fs.storage.chunk_size(); - - let root_fd = fs.root_fd(); - let fd = create_file_with_size(filename, chunk_size as FileSize * 2 + 500, &mut fs); - - let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); - - let vec = vec![0; chunk_size * 2 + 500]; - - let expected = String::from_utf8(vec).unwrap(); - - assert_eq!(content, expected); - - write_text_at_offset(&mut fs, fd, "abc", 33, chunk_size as FileSize + 100).unwrap(); - - let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); - - let mut expected = vec![0u8; chunk_size * 2 + 500]; - - let pattern = b"abc".repeat(33); - expected[chunk_size + 100..chunk_size + 100 + 99].copy_from_slice(&pattern[..]); - - let expected = String::from_utf8(expected).unwrap(); - - assert_eq!(content, expected); - } - } - - #[test] - fn filename_cached_on_open_or_create() { - let filename = "test.txt"; - - for mut fs in test_fs_setups("") { - let root_fd = fs.root_fd(); - let fd = fs - .open_or_create(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) - .unwrap(); - - fs.close(fd).unwrap(); - - assert_eq!(fs.names_cache.get_nodes().len(), 1); - } - } - - #[test] - fn deleted_file_cannot_be_found() { - let filename = "test.txt"; - - for mut fs in test_fs_setups("") { - let root_fd = fs.root_fd(); - let fd = fs - .open_or_create(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) - .unwrap(); - fs.close(fd).unwrap(); - - fs.remove_file(root_fd, filename).unwrap(); - - assert_eq!(fs.names_cache.get_nodes().len(), 0); - - // check we don't increase cache when the file is opened but not created - let fd2 = - fs.open_or_create(root_fd, filename, FdStat::default(), OpenFlags::empty(), 12); - - assert_eq!(fd2, Err(Error::NotFound)); - assert_eq!(fs.names_cache.get_nodes().len(), 0); - } - } - - // test sparse files - #[test] - fn get_stat_of_a_file_that_doesnt_exist() { - let filename = "tmp/test.txt"; - - let mut fs = test_fs(); - - let root_fd = fs.root_fd(); - - let file_fd = create_file_with_size(filename, 15, &mut fs); - - let dir_fd = fs - .open_or_create(root_fd, "tmp", FdStat::default(), OpenFlags::CREATE, 0) - .unwrap(); - - let (filetype, stat) = fs.get_stat(dir_fd).unwrap(); - - println!( - "root = {root_fd}, dir_fd = {dir_fd}, file_fd = {file_fd}, type = {:?}, stat = {:?}", - filetype, stat - ); - - let opened_fd = fs.open_or_create( - root_fd, - "tmp/a.txt", - FdStat::default(), - OpenFlags::empty(), - 0, - ); - - println!("opened_fd = {:?}", opened_fd); - } -} diff --git a/src/fs_tests.rs b/src/fs_tests.rs new file mode 100644 index 0000000..b4f4d4d --- /dev/null +++ b/src/fs_tests.rs @@ -0,0 +1,1491 @@ +use crate::runtime::types::Whence; + +#[cfg(test)] +mod tests { + use crate::fs::FileSystem; + use crate::runtime::types::Fd; + use crate::storage::types::Node; + + use ic_stable_structures::memory_manager::{MemoryId, MemoryManager}; + use ic_stable_structures::{Memory, VectorMemory}; + + use crate::test_utils::write_text_at_offset; + use crate::{ + error::Error, + fs::{DstBuf, FdFlags, SrcBuf}, + runtime::{ + structure_helpers::find_node, + types::{FdStat, OpenFlags}, + }, + storage::{ + stable::StableStorage, + types::{FileSize, FileType}, + }, + test_utils::{ + new_vector_memory, read_text_file, test_fs, test_fs_setups, test_fs_transient, + write_text_fd, write_text_file, + }, + }; + + #[test] + fn get_root_info() { + let fs = test_fs(); + + let fd = fs.root_fd(); + let path = fs.root_path(); + + assert!(fd == 3); + assert!(path == "/"); + } + + #[test] + fn create_file() { + let mut fs = test_fs(); + + let file = fs + .open( + fs.root_fd(), + "test.txt", + Default::default(), + OpenFlags::CREATE, + 0, + ) + .unwrap(); + + assert!(file > fs.root_fd()); + } + + #[test] + fn create_dir() { + let mut fs = test_fs(); + + let dir = fs + .create_open_directory(fs.root_fd(), "test", FdStat::default(), 0) + .unwrap(); + + let fd = fs + .create_open_file(dir, "file.txt", FdStat::default(), 0) + .unwrap(); + + fs.write(fd, "Hello, world!".as_bytes()).unwrap(); + + let dir = fs + .open( + fs.root_fd(), + "test", + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); + + let fd = fs + .open(dir, "file.txt", FdStat::default(), OpenFlags::empty(), 0) + .unwrap(); + + let mut buf = [0; 13]; + fs.read(fd, &mut buf).unwrap(); + assert_eq!(&buf, "Hello, world!".as_bytes()); + } + + #[test] + fn create_file_creates_a_few_files() { + let mut fs = test_fs(); + + let dir = fs.root_fd(); + + fs.create_open_file(dir, "test1.txt", FdStat::default(), 0) + .unwrap(); + fs.create_open_file(dir, "test2.txt", FdStat::default(), 0) + .unwrap(); + fs.create_open_file(dir, "test3.txt", FdStat::default(), 0) + .unwrap(); + + let meta = fs.metadata(fs.root_fd()).unwrap(); + + let entry_index = meta.first_dir_entry.unwrap(); + + let entry1 = fs.get_direntry(fs.root_fd(), entry_index).unwrap(); + let entry2 = fs.get_direntry(fs.root_fd(), entry_index + 1).unwrap(); + let entry3 = fs.get_direntry(fs.root_fd(), entry_index + 2).unwrap(); + + assert_eq!(entry1.prev_entry, None); + assert_eq!(entry1.next_entry, Some(entry_index + 1)); + + assert_eq!(entry2.prev_entry, Some(entry_index)); + assert_eq!(entry2.next_entry, Some(entry_index + 2)); + + assert_eq!(entry3.prev_entry, Some(entry_index + 1)); + assert_eq!(entry3.next_entry, None); + } + + #[test] + fn close_file_fd_reused() { + let mut fs = test_fs(); + + let dir = fs.root_fd(); + + fs.create_open_file(dir, "test1.txt", FdStat::default(), 0) + .unwrap(); + let fd2 = fs + .create_open_file(dir, "test2.txt", FdStat::default(), 0) + .unwrap(); + fs.create_open_file(dir, "test3.txt", FdStat::default(), 0) + .unwrap(); + + fs.close(fd2).unwrap(); + + let fd4 = fs + .create_open_file(dir, "test4.txt", FdStat::default(), 0) + .unwrap(); + + assert_eq!(fd2, fd4); + } + + #[test] + fn fd_renumber() { + for mut fs in test_fs_setups("test1.txt") { + let dir = fs.root_fd(); + + let fd1 = fs + .open(dir, "test1.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let fd2 = fs + .create_open_file(dir, "test2.txt", FdStat::default(), 0) + .unwrap(); + + let entry1 = fs.get_node(fd1); + + fs.renumber(fd1, fd2).unwrap(); + + assert!(fs.get_node(fd1).is_err()); + assert_eq!(fs.get_node(fd2), entry1); + } + } + + #[test] + fn seek_and_write() { + for mut fs in test_fs_setups("test.txt") { + let dir = fs.root_fd(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.seek(fd, 24, super::Whence::SET).unwrap(); + + fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); + + let meta = fs.metadata(fd).unwrap(); + + assert_eq!(meta.size, 29); + + fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); + let mut buf = [42u8; 29]; + let rr = fs.read(fd, &mut buf).unwrap(); + assert_eq!(rr, 29); + assert_eq!( + buf, + [ + 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, + 3, 4, 5 + ] + ); + + fs.close(fd).unwrap(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let mut buf = [42u8; 29]; + let rr = fs.read(fd, &mut buf).unwrap(); + assert_eq!(rr, 29); + assert_eq!( + buf, + [ + 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, + 3, 4, 5 + ] + ); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn read_and_write_vec() { + for mut fs in test_fs_setups("test.txt") { + let dir = fs.root_fd(); + + let write_content1 = "This is a sample file content."; + let write_content2 = "1234567890"; + + let write_content = [ + SrcBuf { + buf: write_content1.as_ptr(), + len: write_content1.len(), + }, + SrcBuf { + buf: write_content2.as_ptr(), + len: write_content2.len(), + }, + ]; + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.write_vec(fd, write_content.as_ref()).unwrap(); + + let meta = fs.metadata(fd).unwrap(); + assert_eq!(meta.size, 40); + + fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); + + let mut read_content1 = String::from("......................"); + let mut read_content2 = String::from("......................"); + + let read_content = [ + DstBuf { + buf: read_content1.as_mut_ptr(), + len: read_content1.len(), + }, + DstBuf { + buf: read_content2.as_mut_ptr(), + len: read_content2.len(), + }, + ]; + + fs.read_vec(fd, &read_content).unwrap(); + + assert_eq!("This is a sample file ", read_content1); + assert_eq!("content.1234567890....", read_content2); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn read_and_write_vec_with_offset() { + for mut fs in test_fs_setups("test.txt") { + let dir = fs.root_fd(); + + let write_content1 = "This is a sample file content."; + let write_content2 = "1234567890"; + + let write_content = [ + SrcBuf { + buf: write_content1.as_ptr(), + len: write_content1.len(), + }, + SrcBuf { + buf: write_content2.as_ptr(), + len: write_content2.len(), + }, + ]; + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.write_vec_with_offset(fd, write_content.as_ref(), 2) + .unwrap(); + + let meta = fs.metadata(fd).unwrap(); + assert_eq!(meta.size, 42); + + fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); + + let mut read_content1 = String::from("......................"); + let mut read_content2 = String::from("......................"); + + let read_content = [ + DstBuf { + buf: read_content1.as_mut_ptr(), + len: read_content1.len(), + }, + DstBuf { + buf: read_content2.as_mut_ptr(), + len: read_content2.len(), + }, + ]; + + fs.read_vec_with_offset(fd, &read_content, 1).unwrap(); + + assert_eq!("\0This is a sample file", read_content1); + assert_eq!(" content.1234567890...", read_content2); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn seek_and_write_transient() { + let mut fs = test_fs_transient(); + + let dir = fs.root_fd(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.seek(fd, 24, super::Whence::SET).unwrap(); + + fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); + + let meta = fs.metadata(fd).unwrap(); + + assert_eq!(meta.size, 29); + + fs.seek(fd, 0, crate::fs::Whence::SET).unwrap(); + let mut buf = [42u8; 29]; + let rr = fs.read(fd, &mut buf).unwrap(); + assert_eq!(rr, 29); + assert_eq!( + buf, + [ + 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, + 4, 5 + ] + ); + + fs.close(fd).unwrap(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let mut buf = [42u8; 29]; + let rr = fs.read(fd, &mut buf).unwrap(); + assert_eq!(rr, 29); + assert_eq!( + buf, + [ + 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, + 4, 5 + ] + ); + + fs.close(fd).unwrap(); + } + + #[test] + fn create_and_remove_file() { + for mut fs in test_fs_setups("virtual_memory.txt") { + let dir = fs.root_fd(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); + fs.close(fd).unwrap(); + + fs.remove_file(dir, "test.txt").unwrap(); + + let err = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::empty(), 0) + .unwrap_err(); + assert_eq!(err, Error::BadFileDescriptor); + } + } + + #[test] + fn cannot_remove_opened_file() { + for mut fs in test_fs_setups("virtual_memory.txt") { + let dir = fs.root_fd(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.write(fd, &[1, 2, 3, 4, 5]).unwrap(); + + let err = fs.remove_file(dir, "test.txt").unwrap_err(); + assert_eq!(err, Error::TextFileBusy); + + fs.close(fd).unwrap(); + fs.remove_file(dir, "test.txt").unwrap(); + } + } + + #[test] + fn cannot_remove_directory_as_file() { + for mut fs in test_fs_setups("virtual_memory.txt") { + let dir = fs.root_fd(); + + let fd = fs + .create_open_directory(dir, "test", FdStat::default(), 0) + .unwrap(); + fs.close(fd).unwrap(); + + let err = fs.remove_file(dir, "test").unwrap_err(); + assert_eq!(err, Error::IsDirectory); + + fs.remove_dir(dir, "test").unwrap(); + } + } + + #[test] + fn cannot_remove_file_as_directory() { + for mut fs in test_fs_setups("virtual_memory.txt") { + let dir = fs.root_fd(); + + let fd = fs + .open(dir, "test.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + fs.close(fd).unwrap(); + + let err = fs.remove_dir(dir, "test.txt").unwrap_err(); + assert_eq!(err, Error::NotADirectoryOrSymbolicLink); + + fs.remove_file(dir, "test.txt").unwrap(); + } + } + + #[test] + fn remove_file_in_a_subdir() { + for mut fs in test_fs_setups("") { + let root_fd = fs.root_fd(); + + // create dirs and a file + let fd = fs + .open( + root_fd, + "dir1/dir2/test.txt", + FdStat::default(), + OpenFlags::CREATE, + 0, + ) + .unwrap(); + fs.close(fd).unwrap(); + + // remove one by one + fs.remove_file(root_fd, "dir1/dir2/test.txt").unwrap(); + fs.remove_dir(root_fd, "dir1/dir2").unwrap(); + fs.remove_dir(root_fd, "dir1").unwrap(); + } + } + + #[test] + fn renumber_when_the_alternative_file_exists() { + for mut fs in test_fs_setups("virtual_memory.txt") { + let dir = fs.root_fd(); + + let fd1 = fs + .open(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); + + let pos1 = fs.tell(fd1).unwrap(); + + let fd2 = fs + .open(dir, "file2.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let pos2 = fs.tell(fd2).unwrap(); + + assert!(pos1 == 5); + assert!(pos2 == 0); + + fs.renumber(fd1, fd2).unwrap(); + + let pos2_renumbered = fs.tell(fd2).unwrap(); + + assert!(pos1 == pos2_renumbered); + + let res = fs.tell(fd1); + + assert!(res.is_err()); + } + } + + #[test] + fn renumber_when_the_alternative_file_doesnt_exist() { + for mut fs in test_fs_setups("file1.txt") { + let dir = fs.root_fd(); + + let fd1 = fs + .open(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); + + let pos1 = fs.tell(fd1).unwrap(); + + assert!(pos1 == 5); + + let fd2 = 100; + + fs.renumber(fd1, fd2).unwrap(); + + let pos2_renumbered = fs.tell(fd2).unwrap(); + + assert!(pos1 == pos2_renumbered); + + let res = fs.tell(fd1); + + assert!(res.is_err()); + } + } + + #[test] + fn set_modified_set_accessed_time() { + for mut fs in test_fs_setups("") { + let dir = fs.root_fd(); + + let fd1 = fs + .open(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 111) + .unwrap(); + + fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); + + fs.set_accessed_time(fd1, 333).unwrap(); + fs.set_modified_time(fd1, 222).unwrap(); + + let metadata = fs.metadata(fd1).unwrap(); + + let times = metadata.times; + + assert_eq!(times.accessed, 333); + assert_eq!(times.modified, 222); + assert_eq!(times.created, 111); + + assert_eq!(metadata.size, 5); + assert_eq!(metadata.file_type, FileType::RegularFile); + } + } + + #[test] + fn set_stat_get_stat() { + let mut fs = test_fs(); + let dir = fs.root_fd(); + + let fd1 = fs + .open(dir, "file1.txt", FdStat::default(), OpenFlags::CREATE, 111) + .unwrap(); + + fs.write(fd1, &[1, 2, 3, 4, 5]).unwrap(); + + let (file_type, mut stat) = fs.get_stat(fd1).unwrap(); + + assert_eq!(file_type, FileType::RegularFile); + + assert_eq!(stat.flags, FdFlags::empty()); + + stat.flags = FdFlags::APPEND; + + fs.set_stat(fd1, stat).unwrap(); + + let (_, stat2) = fs.get_stat(fd1).unwrap(); + + assert_eq!(stat2.flags, FdFlags::APPEND); + } + + fn create_test_file_with_content( + fs: &mut FileSystem, + parent: Fd, + file_name: &str, + content: Vec, + ) -> Fd { + let file_fd = fs + .create_open_file(parent, file_name, FdStat::default(), 0) + .unwrap(); + + let mut src = String::from(""); + + for str in content.iter() { + src.push_str(str.as_str()); + } + + let bytes_written = fs.write(file_fd, src.as_bytes()).unwrap(); + + assert!(bytes_written > 0); + + file_fd + } + + fn create_test_file(fs: &mut FileSystem, parent_fd: Fd, file_name: &str) -> Fd { + create_test_file_with_content( + fs, + parent_fd, + file_name, + vec![ + String::from("This is a sample text."), + String::from("1234567890"), + ], + ) + } + + #[test] + fn link_seek_tell() { + let mut fs = test_fs(); + let dir = fs.root_fd(); + + let root_fd = 3i32; + + let file_name1 = String::from("file.txt"); + let file_name2 = String::from("file_link.txt"); + + let file_fd = create_test_file(&mut fs, root_fd as Fd, &file_name1); + + let root_node = fs.storage.as_ref().root_node(); + let node1 = find_node( + root_node, + &file_name1, + &mut fs.names_cache, + fs.storage.as_ref(), + ) + .unwrap(); + + // test seek and tell + let position = fs.tell(file_fd).unwrap(); + + assert_eq!(position, 32); + + fs.seek(file_fd, 10, crate::fs::Whence::SET).unwrap(); + + let position_after_seek = fs.tell(file_fd).unwrap(); + + assert_eq!(position_after_seek, 10); + + let mut buf_to_read1 = String::from("..............."); + + let bytes_read = fs + .read(file_fd, unsafe { buf_to_read1.as_bytes_mut() }) + .unwrap(); + + assert_eq!(bytes_read, 15); + assert_eq!(buf_to_read1, "sample text.123"); + + // create link + fs.create_hard_link(dir, &file_name1, dir, &file_name2) + .unwrap(); + + let node2 = find_node( + root_node, + &file_name2, + &mut fs.names_cache, + fs.storage.as_ref(), + ) + .unwrap(); + + assert_eq!(node1, node2); + + let link_file_fd = fs + .open( + dir, + "file_link.txt", + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); + + fs.seek(link_file_fd, 10, crate::fs::Whence::SET).unwrap(); + + let position_link = fs.tell(link_file_fd).unwrap(); + + assert_eq!(position_link, 10); + + let mut buf_to_read1 = String::from("................"); + + let bytes_read = fs + .read(link_file_fd, unsafe { buf_to_read1.as_bytes_mut() }) + .unwrap(); + + assert_eq!(bytes_read, 16); + + assert_eq!(buf_to_read1, "sample text.1234"); + } + + #[test] + fn renaming_folder_with_contents() { + let mut fs = test_fs(); + let root_fd = fs.root_fd(); + + let file_name = String::from("dir1/dir2/file.txt"); + create_test_file(&mut fs, root_fd as Fd, &file_name); + + fs.rename(root_fd, "dir1/dir2", root_fd, "dir2").unwrap(); + + let file_fd = fs + .open( + root_fd, + "dir2/file.txt", + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); + + fs.seek(file_fd, 10, crate::fs::Whence::SET).unwrap(); + + let mut buf_to_read1 = String::from("................"); + + let bytes_read = fs + .read(file_fd, unsafe { buf_to_read1.as_bytes_mut() }) + .unwrap(); + + assert_eq!(bytes_read, 16); + + assert_eq!(buf_to_read1, "sample text.1234"); + } + + #[test] + fn write_and_read_25_files() { + for mut fs in test_fs_setups("auto/my_file_6.txt") { + let root_fd = fs.root_fd(); + const SIZE_OF_FILE: usize = 1_000_000; + + // write files + let dir_name = "auto"; + let file_count: u8 = 25; + + for i in 0..file_count { + let filename = format!("{}/my_file_{}.txt", dir_name, i); + let content = format!("{i}"); + let times = SIZE_OF_FILE / content.len(); + + write_text_file(&mut fs, root_fd, filename.as_str(), content.as_str(), times) + .unwrap(); + } + + // read files + for i in 0..file_count { + let filename = format!("{}/my_file_{}.txt", dir_name, i); + let expected_content = format!("{i}{i}{i}"); + + let text_read = read_text_file( + &mut fs, + root_fd, + filename.as_str(), + 0, + expected_content.len(), + ); + + assert_eq!(expected_content, text_read); + } + } + + // This test should not crash with an error + } + + #[test] + fn empty_path_support() { + let mut fs = test_fs(); + let root_fd = fs.root_fd(); + + write_text_file(&mut fs, root_fd, "f1/f2/text.txt", "content123", 100).unwrap(); + + let content = read_text_file(&mut fs, root_fd, "f1/f2/text.txt", 7, 10); + assert_eq!(content, "123content"); + + let content = read_text_file(&mut fs, root_fd, "f1//f2/text.txt", 6, 10); + assert_eq!(content, "t123conten"); + + let content = read_text_file(&mut fs, root_fd, "/f1//f2/text.txt", 5, 10); + assert_eq!(content, "nt123conte"); + + write_text_file(&mut fs, root_fd, "text.txt", "abc", 100).unwrap(); + + let content = read_text_file(&mut fs, root_fd, "text.txt", 0, 6); + assert_eq!(content, "abcabc"); + + let content = read_text_file(&mut fs, root_fd, "/text.txt", 0, 6); + assert_eq!(content, "abcabc"); + + let content = read_text_file(&mut fs, root_fd, "///////text.txt", 0, 6); + assert_eq!(content, "abcabc"); + + // This test should not crash with an error + } + + #[test] + fn writing_into_mounted_memory() { + let memory: VectorMemory = new_vector_memory(); + + let mut fs = test_fs(); + + let root_fd = fs.root_fd(); + + fs.mount_memory_file("test.txt", Box::new(memory.clone())) + .unwrap(); + + let content = "ABCDEFG123"; + + write_text_file(&mut fs, root_fd, "test.txt", content, 1).unwrap(); + + let mut buf = [0u8; 100]; + + memory.read(0, &mut buf); + + println!("{:?}", buf); + } + + #[test] + fn reading_mounted_memory_after_upgrade() { + let memory_manager = MemoryManager::init(new_vector_memory()); + let memory = memory_manager.get(MemoryId::new(1)); + + let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210); + let mut fs = FileSystem::new(Box::new(storage)).unwrap(); + fs.mount_memory_file("test.txt", Box::new(memory.clone())) + .unwrap(); + + let root_fd = fs.root_fd(); + let content = "ABCDEFG123"; + write_text_file(&mut fs, root_fd, "test.txt", content, 2).unwrap(); + + // imitate canister upgrade (we keep the memory manager but recreate the file system with the same virtual memories) + let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210); + let mut fs = FileSystem::new(Box::new(storage)).unwrap(); + fs.mount_memory_file("test.txt", Box::new(memory.clone())) + .unwrap(); + let root_fd = fs.root_fd(); + + let content = read_text_file(&mut fs, root_fd, "test.txt", 0, 100); + + assert_eq!(content, "ABCDEFG123ABCDEFG123"); + } + + #[test] + fn deleting_mounted_file_fails() { + let memory: VectorMemory = new_vector_memory(); + + let mut fs = test_fs(); + + let root_fd = fs.root_fd(); + + fs.mount_memory_file("test.txt", Box::new(memory.clone())) + .unwrap(); + + let res = fs.remove_file(root_fd, "test.txt"); + + assert!( + res == Err(Error::TextFileBusy), + "Deleting a mounted file should not be allowed!" + ); + + // check the dir entry still exists after deletion + let files = fs.list_dir_internal(root_fd, None).unwrap(); + + assert_eq!(files[0].1, "test.txt".to_string()); + } + + #[test] + fn mounted_memory_store_and_init_roundtrip() { + for mut fs in test_fs_setups("") { + let memory1: VectorMemory = new_vector_memory(); + let memory2: VectorMemory = new_vector_memory(); + + let file_name = "test.txt"; + + fs.mount_memory_file(file_name, Box::new(memory1.clone())) + .unwrap(); + + let content = "ABCDEFG123"; + let len = content.len(); + let count = 1000; + + memory1.grow(5); + + // fill up memory with some data + for i in 0..count { + memory1.write(i as u64 * len as u64, content.as_bytes()); + } + + let fd = fs + .open( + fs.root_fd, + file_name, + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); + let mut metadata = fs.metadata(fd).unwrap(); + metadata.size = len as FileSize * count as FileSize; + fs.set_metadata(fd, metadata).unwrap(); + fs.close(fd).unwrap(); + + // store memory into a file + fs.store_memory_file(file_name).unwrap(); + + fs.unmount_memory_file(file_name).unwrap(); + + fs.mount_memory_file(file_name, Box::new(memory2.clone())) + .unwrap(); + + // init new memory into a file + fs.init_memory_file(file_name).unwrap(); + + let mut buf1 = [0u8; 10]; + let mut buf2 = [0u8; 10]; + + for i in 0..count { + memory1.read(i as u64 * len as u64, &mut buf1); + memory2.read(i as u64 * len as u64, &mut buf2); + + assert_eq!(buf1, buf2); + } + } + } + + #[test] + fn writing_from_different_file_descriptors() { + for mut fs in test_fs_setups("f1/f2/text.txt") { + let root_fd = fs.root_fd(); + + let fd1 = fs + .open( + root_fd, + "f1/f2/text.txt", + FdStat::default(), + OpenFlags::CREATE, + 40, + ) + .unwrap(); + let fd2 = fs + .open( + root_fd, + "f1//f2/text.txt", + FdStat::default(), + OpenFlags::CREATE, + 44, + ) + .unwrap(); + + write_text_fd(&mut fs, fd1, "abc", 1).unwrap(); + write_text_fd(&mut fs, fd2, "123", 1).unwrap(); + write_text_fd(&mut fs, fd1, "xyz", 1).unwrap(); + + let content = read_text_file(&mut fs, root_fd, "/f1/f2/text.txt", 0, 9); + + assert_eq!("123xyz", content); + } + } + + #[test] + fn write_into_empty_filename_fails() { + for mut fs in test_fs_setups("") { + let root_fd = fs.root_fd(); + let res = write_text_file(&mut fs, root_fd, "", "content123", 100); + assert!(res.is_err()); + } + } + + fn create_file_with_size(filename: &str, size: FileSize, fs: &mut FileSystem) -> Fd { + let fd = fs + .open( + fs.root_fd, + filename, + FdStat::default(), + OpenFlags::CREATE, + 12, + ) + .unwrap(); + let mut meta = fs.metadata(fd).unwrap(); + meta.size = size; + + fs.set_metadata(fd, meta).unwrap(); + + fd + } + + // test sparse files + #[test] + fn set_size_for_an_empty_file() { + let filename = "test.txt"; + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + let fd = create_file_with_size(filename, 15, &mut fs); + + let content = read_text_file(&mut fs, root_fd, filename, 0, 100); + + assert_eq!(content, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"); + + write_text_at_offset(&mut fs, fd, "abc", 3, 3).unwrap(); + + let content = read_text_file(&mut fs, root_fd, filename, 1, 100); + + assert_eq!(content, "\0\0abcabcabc\0\0\0"); + } + } + + #[test] + fn create_file_missing_chunk_in_the_middle() { + let filename = "test.txt"; + + for mut fs in test_fs_setups(filename) { + let chunk_size = fs.storage.chunk_size(); + + let root_fd = fs.root_fd(); + let fd = create_file_with_size(filename, chunk_size as FileSize * 2 + 500, &mut fs); + + let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); + + let vec = vec![0; chunk_size * 2 + 500]; + let expected = String::from_utf8(vec).unwrap(); + + // expect all zeroes at first + assert_eq!(content, expected); + + // write some text to the first chunk + write_text_at_offset(&mut fs, fd, "abc", 33, 3).unwrap(); + + // write some text to the 100th position of the third chunk + write_text_at_offset(&mut fs, fd, "abc", 33, chunk_size as FileSize * 2 + 100).unwrap(); + + // read what we have now + let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); + + let mut expected = vec![0u8; chunk_size * 2 + 500]; + + let pattern = b"abc".repeat(33); + expected[3..3 + 99].copy_from_slice(&pattern[..]); + expected[chunk_size * 2 + 100..chunk_size * 2 + 100 + 99].copy_from_slice(&pattern[..]); + + let expected = String::from_utf8(expected).unwrap(); + + assert_eq!(content, expected); + } + } + + #[test] + fn iterate_file_only_middle_chunk_is_present() { + let filename = "test.txt"; + + for mut fs in test_fs_setups(filename) { + let chunk_size = fs.storage.chunk_size(); + + let root_fd = fs.root_fd(); + let fd = create_file_with_size(filename, chunk_size as FileSize * 2 + 500, &mut fs); + + let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); + + let vec = vec![0; chunk_size * 2 + 500]; + + let expected = String::from_utf8(vec).unwrap(); + + assert_eq!(content, expected); + + write_text_at_offset(&mut fs, fd, "abc", 33, chunk_size as FileSize + 100).unwrap(); + + let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); + + let mut expected = vec![0u8; chunk_size * 2 + 500]; + + let pattern = b"abc".repeat(33); + expected[chunk_size + 100..chunk_size + 100 + 99].copy_from_slice(&pattern[..]); + + let expected = String::from_utf8(expected).unwrap(); + + assert_eq!(content, expected); + } + } + + #[test] + fn create_larger_file_than_memory_available() { + let filename = "test.txt"; + + for mut fs in test_fs_setups("") { + let chunk_size = fs.storage.chunk_size(); + + let root_fd = fs.root_fd(); + + let fd = create_file_with_size(filename, chunk_size as FileSize * 2 + 500, &mut fs); + + let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); + + let vec = vec![0; chunk_size * 2 + 500]; + + let expected = String::from_utf8(vec).unwrap(); + + assert_eq!(content, expected); + + write_text_at_offset(&mut fs, fd, "abc", 33, chunk_size as FileSize + 100).unwrap(); + + let content = read_text_file(&mut fs, root_fd, filename, 0, chunk_size * 10); + + let mut expected = vec![0u8; chunk_size * 2 + 500]; + + let pattern = b"abc".repeat(33); + expected[chunk_size + 100..chunk_size + 100 + 99].copy_from_slice(&pattern[..]); + + let expected = String::from_utf8(expected).unwrap(); + + assert_eq!(content, expected); + } + } + + #[test] + fn filename_cached_on_open_or_create() { + let filename = "test.txt"; + + for mut fs in test_fs_setups("") { + let root_fd = fs.root_fd(); + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) + .unwrap(); + + fs.close(fd).unwrap(); + + assert_eq!(fs.names_cache.get_nodes().len(), 1); + } + } + + #[test] + fn deleted_file_cannot_be_found() { + let filename = "test.txt"; + + for mut fs in test_fs_setups("") { + let root_fd = fs.root_fd(); + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) + .unwrap(); + fs.close(fd).unwrap(); + + fs.remove_file(root_fd, filename).unwrap(); + + assert_eq!(fs.names_cache.get_nodes().len(), 0); + + // check we don't increase cache when the file is opened but not created + let fd2 = fs.open(root_fd, filename, FdStat::default(), OpenFlags::empty(), 12); + + assert_eq!(fd2, Err(Error::BadFileDescriptor)); + assert_eq!(fs.names_cache.get_nodes().len(), 0); + } + } + + // test sparse files + #[test] + fn get_stat_of_a_file_that_doesnt_exist() { + let filename = "tmp/test.txt"; + + let mut fs = test_fs(); + + let root_fd = fs.root_fd(); + + let file_fd = create_file_with_size(filename, 15, &mut fs); + + let dir_fd = fs + .open(root_fd, "tmp", FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let (filetype, stat) = fs.get_stat(dir_fd).unwrap(); + + println!( + "root = {root_fd}, dir_fd = {dir_fd}, file_fd = {file_fd}, type = {:?}, stat = {:?}", + filetype, stat + ); + + let opened_fd = fs.open( + root_fd, + "tmp/a.txt", + FdStat::default(), + OpenFlags::empty(), + 0, + ); + + println!("opened_fd = {:?}", opened_fd); + } + + #[test] + fn writing_beyond_maximum_size_fails() { + let filename = "test.txt"; + let max_size: FileSize = 100; // Maximum file size allowed. + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + + // Create the file and set the maximum size limit. + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) + .unwrap(); + + fs.set_file_size_limit(fd, max_size).unwrap(); + + // Try writing data within the size limit. + let within_limit_data = vec![1u8; 50]; + assert!(fs.write(fd, &within_limit_data).is_ok()); + + // Try writing data that would exceed the limit. + let exceeding_data = vec![1u8; 60]; + let result = fs.write(fd, &exceeding_data); + assert_eq!(result.unwrap_err(), Error::FileTooLarge); + + // Ensure the file size does not exceed the limit. + let metadata = fs.metadata(fd).unwrap(); + assert!(metadata.size <= max_size); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn appending_to_exact_limit() { + let filename = "test_append.txt"; + let max_size: FileSize = 20000; // Maximum file size allowed. + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + + // Create the file and set the maximum size limit. + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) + .unwrap(); + fs.set_file_size_limit(fd, max_size).unwrap(); + + // Write data initially within the limit (mroe than 1 chunk used). + let initial_data = vec![1u8; 15000]; + assert!(fs.write(fd, &initial_data).is_ok()); + + // Stop exactly on the egde of file size + let additional_data = vec![1u8; 5000]; + assert!(fs.write(fd, &additional_data).is_ok()); + + // Attempt to append just one more byte fails. + let append_data = vec![1u8; 1]; + let result = fs.write(fd, &append_data); + assert_eq!(result.unwrap_err(), Error::FileTooLarge); + + // Verify the file size remains within the limit. + let metadata = fs.metadata(fd).unwrap(); + assert!(metadata.size <= max_size); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn seek_and_write_beyond_maximum_size_fails() { + let filename = "test_seek.txt"; + let max_size: FileSize = 150; // Maximum file size allowed. + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + + // Create the file and set the maximum size limit. + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) + .unwrap(); + fs.set_file_size_limit(fd, max_size).unwrap(); + + // Seek to a position within the size limit and write. + fs.seek(fd, 100, super::Whence::SET).unwrap(); + let within_limit_data = vec![1u8; 30]; + assert!(fs.write(fd, &within_limit_data).is_ok()); + + // Seek to a position that would exceed the limit and attempt to write. + fs.seek(fd, 140, super::Whence::SET).unwrap(); + let exceeding_data = vec![1u8; 20]; + let result = fs.write(fd, &exceeding_data); + assert_eq!(result.unwrap_err(), Error::FileTooLarge); + + // Verify the file size remains within the limit. + let metadata = fs.metadata(fd).unwrap(); + assert!(metadata.size <= max_size); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn write_vec_beyond_maximum_size_fails() { + let filename = "test_vec.txt"; + let max_size: FileSize = 120; // Maximum file size allowed. + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + + // Create the file and set the maximum size limit. + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 12) + .unwrap(); + + fs.set_file_size_limit(fd, max_size).unwrap(); + + // Prepare vector data. + let within_limit_data = vec![ + SrcBuf { + buf: vec![1u8; 50].as_ptr(), + len: 50, + }, + SrcBuf { + buf: vec![1u8; 40].as_ptr(), + len: 40, + }, + ]; + assert!(fs.write_vec(fd, within_limit_data.as_ref()).is_ok()); + + // expect file size to be 90 + let meta = fs.metadata(fd).unwrap(); + assert_eq!(meta.size, 90); + + // Prepare vector data that exceeds the limit. + let exceeding_data = vec![ + SrcBuf { + buf: vec![1u8; 20].as_ptr(), + len: 20, + }, + SrcBuf { + buf: vec![1u8; 80].as_ptr(), + len: 80, + }, + ]; + let result = fs.write_vec(fd, exceeding_data.as_ref()); + assert_eq!(result.unwrap_err(), Error::FileTooLarge); + + // expect only the first buffer to be stored + let meta = fs.metadata(fd).unwrap(); + assert_eq!(meta.size, 110); + + fs.close(fd).unwrap(); + } + } + + #[test] + fn shrinking_file_size_truncates_data() { + let filename = "shrink_test.txt"; + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + + // Step 1: Create a file and write some content. + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let content = "This is some sample text for testing file shrinking."; + fs.write(fd, content.as_bytes()).unwrap(); + + // Verify the initial file size matches the written content. + let metadata = fs.metadata(fd).unwrap(); + assert_eq!(metadata.size as usize, content.len()); + + // Step 2: Shrink the file size. + let new_size: FileSize = 20; + let mut metadata = fs.metadata(fd).unwrap(); + metadata.size = new_size; + fs.set_metadata(fd, metadata).unwrap(); + + // Verify the file size is updated. + let shrunk_metadata = fs.metadata(fd).unwrap(); + assert_eq!(shrunk_metadata.size, new_size); + + // Step 3: Read back the content and verify it is truncated. + let mut buffer = vec![0u8; new_size as usize]; + fs.seek(fd, 0, super::Whence::SET).unwrap(); // Seek to the start of the file. + let read_size = fs.read(fd, &mut buffer).unwrap(); + assert_eq!(read_size, new_size); + + let expected_content = &content[0..new_size as usize]; + assert_eq!(String::from_utf8(buffer).unwrap(), expected_content); + + // Close the file. + fs.close(fd).unwrap(); + } + } + + #[test] + fn shrinking_max_file_size_truncates_data() { + let filename = "shrink_test.txt"; + + for mut fs in test_fs_setups(filename) { + let root_fd = fs.root_fd(); + + // Step 1: Create a file and write some content. + let fd = fs + .open(root_fd, filename, FdStat::default(), OpenFlags::CREATE, 0) + .unwrap(); + + let content = "This is some sample text for testing file shrinking."; + fs.write(fd, content.as_bytes()).unwrap(); + + // Verify the initial file size matches the written content. + let metadata = fs.metadata(fd).unwrap(); + assert_eq!(metadata.size as usize, content.len()); + + // Step 2: Shrink the file size. + let new_size: FileSize = 20; + let mut metadata = fs.metadata(fd).unwrap(); + metadata.size = new_size; + metadata.maximum_size_allowed = Some(new_size); + fs.set_metadata(fd, metadata).unwrap(); + + // Verify the file size is updated. + let shrunk_metadata = fs.metadata(fd).unwrap(); + assert_eq!(shrunk_metadata.size, new_size); + + // Step 3: Read back the content and verify it is truncated. + let mut buffer = vec![0u8; new_size as usize]; + fs.seek(fd, 0, super::Whence::SET).unwrap(); // Seek to the start of the file. + let read_size = fs.read(fd, &mut buffer).unwrap(); + assert_eq!(read_size, new_size); + + let expected_content = &content[0..new_size as usize]; + assert_eq!(String::from_utf8(buffer).unwrap(), expected_content); + + // Close the file. + fs.close(fd).unwrap(); + } + } + + #[test] + fn remove_dir_recurse_test() { + let mut fs = test_fs(); + let root_fd = fs.root_fd(); + // create test directory structure: + // /subdir + // /subdir/file1.txt + // /subdir/nested + // /subdir/nested/file2.txt + + // Create a directory structure and close all file descriptors + fs.mkdir(root_fd, "subdir", FdStat::default(), 0).unwrap(); + + let fd = fs + .create_open_file(root_fd, "subdir/file1.txt", FdStat::default(), 0) + .unwrap(); + fs.close(fd).unwrap(); + + fs.mkdir(root_fd, "subdir/nested", FdStat::default(), 0) + .unwrap(); + + let fd = fs + .create_open_file(root_fd, "subdir/nested/file2.txt", FdStat::default(), 0) + .unwrap(); + fs.close(fd).unwrap(); + + // Now remove `subdir` recursively (this should remove `nested` and its contents as well). + fs.remove_recursive(root_fd, "subdir").unwrap(); + + // Check subdir was deleted. + let result = fs.open(root_fd, "subdir", FdStat::default(), OpenFlags::empty(), 0); + assert!( + result.is_err(), + "Expected an error when trying to open a removed directory" + ); + + // assert we get the right file descriptor back + assert_eq!( + result.unwrap_err(), + Error::BadFileDescriptor, + "Unexpected error type" + ); + + // internal memory check, since all files were deleted, there should be no metadata nodes left in the system (appart from the 0 node) + for i in 1..10 { + let result = fs.storage.get_metadata(i as Node); + assert!( + result.is_err(), + "Expected an error when trying to get any metadata from the storage" + ); + } + } +} diff --git a/src/integration_tests.rs b/src/integration_tests.rs index ad51993..f595c1f 100644 --- a/src/integration_tests.rs +++ b/src/integration_tests.rs @@ -192,6 +192,25 @@ mod fns { panic!("unintended call failure!"); } } + + pub(crate) fn check_metadata_binary(pic: &PocketIc) -> String { + let response = pic + .query_call( + active_canister(), + Principal::anonymous(), + "check_metadata_binary", + encode_one(()).unwrap(), + ) + .unwrap(); + + if let WasmResult::Reply(response) = response { + let result: String = decode_one(&response).unwrap(); + + result + } else { + panic!("unintended call failure!"); + } + } } #[test] @@ -538,3 +557,16 @@ fn large_file_second_write() { assert_eq!(size, 100_000_000); } + +#[test] +fn check_metadata_binary() { + let pic = setup_initial_canister(); + + // we should track any changes that affect Metadata binary representation in memory + // as it is stored directly without explicit serialization for the sake of performance. + let bin = fns::check_metadata_binary(&pic); + + // object memory is prefilled with 0xfa explicitly in fns::check_metadata_binary to ensure stable test + assert_eq!(&bin, + "030000000000000004fafafafafafafa06000000000000000800000000000000410000000000000042000000000000004300000000000000010000000c000000010000000d00000002fafafafafafafa0100000000000000abcd000000000000"); +} diff --git a/src/lib.rs b/src/lib.rs index 48c6a2f..0b74ae5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,5 +9,8 @@ mod runtime; #[cfg(test)] mod test_utils; +#[cfg(test)] +mod fs_tests; + #[cfg(test)] mod integration_tests; diff --git a/src/runtime.rs b/src/runtime.rs index 502e0c2..f93eabe 100644 --- a/src/runtime.rs +++ b/src/runtime.rs @@ -1,5 +1,5 @@ -pub mod dir; -pub mod fd; -pub mod file; +pub(crate) mod dir; +pub(crate) mod fd; +pub(crate) mod file; pub(crate) mod structure_helpers; pub mod types; diff --git a/src/runtime/dir.rs b/src/runtime/dir.rs index aaa3e3d..71b69b1 100644 --- a/src/runtime/dir.rs +++ b/src/runtime/dir.rs @@ -45,9 +45,10 @@ impl Dir { ctime: u64, ) -> Result { let found = find_node(self.node, path, names_cache, storage); + match found { - Err(Error::NotFound) => {} - Ok(_) => return Err(Error::FileAlreadyExists), + Err(Error::BadFileDescriptor) => {} + Ok(_) => return Err(Error::FileExists), Err(err) => return Err(err), } @@ -94,8 +95,8 @@ impl Dir { ) -> Result { let found = find_node(self.node, path, names_cache, storage); match found { - Err(Error::NotFound) => {} - Ok(_) => return Err(Error::FileAlreadyExists), + Err(Error::BadFileDescriptor) => {} + Ok(_) => return Err(Error::FileExists), Err(err) => return Err(err), } @@ -153,15 +154,15 @@ mod tests { let dir = fs.root_fd(); let fd = fs - .create_file(dir, "test1.txt", FdStat::default(), 0) + .create_open_file(dir, "test1.txt", FdStat::default(), 0) .unwrap(); fs.close(fd).unwrap(); let fd = fs - .create_file(dir, "test2.txt", FdStat::default(), 0) + .create_open_file(dir, "test2.txt", FdStat::default(), 0) .unwrap(); fs.close(fd).unwrap(); let fd = fs - .create_file(dir, "test3.txt", FdStat::default(), 0) + .create_open_file(dir, "test3.txt", FdStat::default(), 0) .unwrap(); fs.close(fd).unwrap(); @@ -192,10 +193,12 @@ mod tests { let dir = fs.root_fd(); - let new_dir_fd = fs.create_dir(dir, "dir1", FdStat::default(), 123).unwrap(); + let new_dir_fd = fs + .create_open_directory(dir, "dir1", FdStat::default(), 123) + .unwrap(); let new_file_fd = fs - .create_file(dir, "test.txt", FdStat::default(), 234) + .create_open_file(dir, "test.txt", FdStat::default(), 234) .unwrap(); let dir_meta = fs.metadata(new_dir_fd).unwrap(); @@ -217,7 +220,7 @@ mod tests { let dir = fs.root_fd(); let fd = fs - .create_file(dir, "test2.txt", FdStat::default(), 0) + .create_open_file(dir, "test2.txt", FdStat::default(), 0) .unwrap(); fs.close(fd).unwrap(); @@ -237,7 +240,7 @@ mod tests { let dir = fs.root_fd(); let fd = fs - .create_file(dir, "test2.txt", FdStat::default(), 0) + .create_open_file(dir, "test2.txt", FdStat::default(), 0) .unwrap(); fs.close(fd).unwrap(); @@ -261,7 +264,7 @@ mod tests { let parent_fd = fs.root_fd(); - fs.create_file(parent_fd, "test1.txt", FdStat::default(), 120) + fs.create_open_file(parent_fd, "test1.txt", FdStat::default(), 120) .unwrap(); let fd2 = fs @@ -280,13 +283,13 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let dir2_fd = fs - .create_dir(root_fd, "dir2", FdStat::default(), 123) + .create_open_directory(root_fd, "dir2", FdStat::default(), 123) .unwrap(); let _dir3_fd = fs - .create_dir(dir1_fd, "dir3", FdStat::default(), 320) + .create_open_directory(dir1_fd, "dir3", FdStat::default(), 320) .unwrap(); let dir4_res = fs.create_hard_link(dir1_fd, "dir3", dir2_fd, "dir4"); @@ -300,16 +303,16 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let file_fd = fs - .create_file(dir1_fd, "test1.txt", FdStat::default(), 120) + .create_open_file(dir1_fd, "test1.txt", FdStat::default(), 120) .unwrap(); fs.close(file_fd).unwrap(); - let res = fs.open_or_create( + let res = fs.open( root_fd, "test1.txt", FdStat::default(), @@ -317,9 +320,9 @@ mod tests { 123, ); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create( + let res = fs.open( root_fd, "dir1/test1.txt", FdStat::default(), @@ -338,11 +341,11 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let file_fd = fs - .create_file(root_fd, "test1.txt", FdStat::default(), 120) + .create_open_file(root_fd, "test1.txt", FdStat::default(), 120) .unwrap(); let fd2 = fs @@ -354,7 +357,7 @@ mod tests { assert_eq!(meta.node, meta2.node); - let res = fs.open_or_create( + let res = fs.open( root_fd, "test1.txt", FdStat::default(), @@ -362,9 +365,9 @@ mod tests { 123, ); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create( + let res = fs.open( dir1_fd, "test2.txt", FdStat::default(), @@ -382,11 +385,11 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let file_fd = fs - .create_file(root_fd, "test1.txt", FdStat::default(), 120) + .create_open_file(root_fd, "test1.txt", FdStat::default(), 120) .unwrap(); let fd2 = fs @@ -398,7 +401,7 @@ mod tests { assert_eq!(meta.node, meta2.node); - let res = fs.open_or_create( + let res = fs.open( root_fd, "test1.txt", FdStat::default(), @@ -406,9 +409,9 @@ mod tests { 123, ); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create( + let res = fs.open( dir1_fd, "test2.txt", FdStat::default(), @@ -426,11 +429,11 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let file_fd = fs - .create_file(dir1_fd, "test1.txt", FdStat::default(), 120) + .create_open_file(dir1_fd, "test1.txt", FdStat::default(), 120) .unwrap(); let fd2 = fs @@ -442,7 +445,7 @@ mod tests { assert_eq!(meta.node, meta2.node); - let res = fs.open_or_create( + let res = fs.open( dir1_fd, "test1.txt", FdStat::default(), @@ -450,9 +453,9 @@ mod tests { 123, ); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create( + let res = fs.open( root_fd, "test2.txt", FdStat::default(), @@ -470,11 +473,11 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let file_fd = fs - .create_file(root_fd, "test1.txt", FdStat::default(), 120) + .create_open_file(root_fd, "test1.txt", FdStat::default(), 120) .unwrap(); let fd2 = fs @@ -486,7 +489,7 @@ mod tests { assert_eq!(meta.node, meta2.node); - let res = fs.open_or_create( + let res = fs.open( root_fd, "test1.txt", FdStat::default(), @@ -494,9 +497,9 @@ mod tests { 123, ); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create( + let res = fs.open( dir1_fd, "test2.txt", FdStat::default(), @@ -514,15 +517,15 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let _file_fd = fs - .create_file(dir1_fd, "test1.txt", FdStat::default(), 123) + .create_open_file(dir1_fd, "test1.txt", FdStat::default(), 123) .unwrap(); let dir2_fd = fs - .create_dir(root_fd, "dir2", FdStat::default(), 125) + .create_open_directory(root_fd, "dir2", FdStat::default(), 125) .unwrap(); let fd2 = fs.rename(root_fd, "dir1", dir2_fd, "dir3").unwrap(); @@ -532,11 +535,11 @@ mod tests { assert_eq!(meta.node, meta2.node); - let res = fs.open_or_create(root_fd, "dir1", FdStat::default(), OpenFlags::empty(), 123); + let res = fs.open(root_fd, "dir1", FdStat::default(), OpenFlags::empty(), 123); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create(dir2_fd, "dir3", FdStat::default(), OpenFlags::empty(), 123); + let res = fs.open(dir2_fd, "dir3", FdStat::default(), OpenFlags::empty(), 123); assert!(res.is_ok()); } @@ -548,15 +551,15 @@ mod tests { let root_fd = fs.root_fd(); let dir1_fd = fs - .create_dir(root_fd, "dir1", FdStat::default(), 120) + .create_open_directory(root_fd, "dir1", FdStat::default(), 120) .unwrap(); let _file_fd = fs - .create_file(dir1_fd, "test1.txt", FdStat::default(), 123) + .create_open_file(dir1_fd, "test1.txt", FdStat::default(), 123) .unwrap(); let dir2_fd = fs - .create_dir(root_fd, "dir2", FdStat::default(), 125) + .create_open_directory(root_fd, "dir2", FdStat::default(), 125) .unwrap(); let fd2 = fs.rename(root_fd, "dir1", root_fd, "dir2/dir3").unwrap(); @@ -566,11 +569,11 @@ mod tests { assert_eq!(meta.node, meta2.node); - let res = fs.open_or_create(root_fd, "dir1", FdStat::default(), OpenFlags::empty(), 123); + let res = fs.open(root_fd, "dir1", FdStat::default(), OpenFlags::empty(), 123); - assert_eq!(res, Err(Error::NotFound)); + assert_eq!(res, Err(Error::BadFileDescriptor)); - let res = fs.open_or_create(dir2_fd, "dir3", FdStat::default(), OpenFlags::empty(), 123); + let res = fs.open(dir2_fd, "dir3", FdStat::default(), OpenFlags::empty(), 123); assert!(res.is_ok()); } diff --git a/src/runtime/fd.rs b/src/runtime/fd.rs index 256c2ab..a183eaa 100644 --- a/src/runtime/fd.rs +++ b/src/runtime/fd.rs @@ -2,13 +2,15 @@ use std::collections::BTreeMap; use crate::{ error::Error, + fs::Fd, runtime::{dir::Dir, file::File}, storage::types::Node, }; -const RESERVED_FD_COUNT: Fd = 3; - -pub type Fd = u32; +// file descriptor used for the main root entry +pub const ROOT_FD: Fd = 3; +// number of file descriptors reserved for standard streams +const FIRST_AVAILABLE_FD: Fd = 4; pub enum FdEntry { File(File), @@ -33,7 +35,7 @@ impl FdTable { Self { table: BTreeMap::default(), node_refcount: BTreeMap::default(), - next_fd: RESERVED_FD_COUNT, + next_fd: FIRST_AVAILABLE_FD, free_fds: vec![], } } @@ -65,6 +67,15 @@ impl FdTable { self.table.get(&fd) } + // open root file descriptor + pub fn open_root(&mut self, entry: FdEntry) -> Fd { + let fd = ROOT_FD; + + let prev = self.insert(fd, entry); + assert!(prev.is_none()); + fd + } + // Open a new file descriptor. pub fn open(&mut self, entry: FdEntry) -> Fd { let fd = match self.free_fds.pop() { @@ -81,14 +92,42 @@ impl FdTable { fd } - // Reassign a file descriptor to a new number, the source descriptor is closed in the process. + // Copy a file descriptor to a new number, the source descriptor is closed in the process. // If the destination descriptor is busy, it is closed in the process. pub fn renumber(&mut self, src: Fd, dst: Fd) -> Result<(), Error> { - let old_entry = self.close(src).ok_or(Error::NotFound)?; + if src == dst { + return Ok(()); + } + + // renumbering between special file descriptors is not allowed + if dst < FIRST_AVAILABLE_FD || src < FIRST_AVAILABLE_FD { + return Err(Error::OperationNotPermitted); + } + + // cannot do renumbering between a file and a folder + let src_entry: Option<&FdEntry> = self.table.get(&src); + let dst_entry: Option<&FdEntry> = self.table.get(&dst); + + if let Some(FdEntry::Dir(_s)) = src_entry { + if let Some(FdEntry::File(_d)) = dst_entry { + return Err(Error::BadFileDescriptor); + } + } + + if let Some(FdEntry::File(_s)) = src_entry { + if let Some(FdEntry::Dir(_d)) = dst_entry { + return Err(Error::BadFileDescriptor); + } + } + + // now assign the source file descriptor to the destination + let old_entry = self.close(src).ok_or(Error::BadFileDescriptor)?; // quietly close the destination file descriptor if let Some(_old_dst_entry) = self.close(dst) { + // dst should not be reused by anyone else, so we must undo the fd marked for reusal let removed = self.free_fds.pop().unwrap(); + // sanity check that the removed fd was indeer dst assert_eq!(removed, dst); } @@ -99,10 +138,17 @@ impl FdTable { // Close file descriptor. pub fn close(&mut self, fd: Fd) -> Option { + if fd == ROOT_FD { + return None; + } + let entry = self.table.remove(&fd); if let Some(entry) = entry { - self.free_fds.push(fd); + if fd >= FIRST_AVAILABLE_FD { + self.free_fds.push(fd); + } + self.dec_node_refcount(&entry); Some(entry) @@ -135,3 +181,176 @@ impl FdTable { } } } + +#[cfg(test)] +mod tests { + use crate::fs::FdStat; + + use super::*; + + #[test] + fn test_fdtable_new() { + let fd_table = FdTable::new(); + assert!(fd_table.table.is_empty()); + assert!(fd_table.node_refcount.is_empty()); + + assert_eq!(fd_table.next_fd, FIRST_AVAILABLE_FD); + assert!(fd_table.free_fds.is_empty()); + } + + #[test] + fn test_fdtable_open_and_get() { + let mut fd_table = FdTable::new(); + let file = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + let fd = fd_table.open(FdEntry::File(file)); + + // Check that the file descriptor was assigned to the first possible value + assert_eq!(fd, FIRST_AVAILABLE_FD); + + // Check that the entry exists in the table + let entry = fd_table.get(fd).unwrap(); + match entry { + FdEntry::File(file) => assert_eq!(file.node, 1), + _ => panic!("Expected a file entry"), + } + } + + #[test] + fn test_fdtable_close() { + let mut fd_table = FdTable::new(); + let file = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + let fd = fd_table.open(FdEntry::File(file)); + + // Close the file descriptor + let entry = fd_table.close(fd); + assert!(entry.is_some()); + + // Ensure the table no longer has the file descriptor + assert!(fd_table.get(fd).is_none()); + + // Ensure the freed FD is available for reuse + assert!(fd_table.free_fds.contains(&fd)); + } + + #[test] + fn test_fdtable_renumber() { + let mut fd_table = FdTable::new(); + let file = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + let src_fd = fd_table.open(FdEntry::File(file)); + let dst_fd = 10; + + // Renumber the file descriptor + fd_table.renumber(src_fd, dst_fd).unwrap(); + + // Ensure the old FD no longer exists + assert!(fd_table.get(src_fd).is_none()); + + // Ensure the new FD points to the correct entry + let entry = fd_table.get(dst_fd).unwrap(); + match entry { + FdEntry::File(file) => assert_eq!(file.node, 1), + _ => panic!("Expected a file entry"), + } + } + + #[test] + fn test_renumber_different_types() { + let mut fd_table = FdTable::new(); + let file = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + + let dir = Dir { + node: 2, + stat: FdStat::default(), + }; + + let fd1 = fd_table.open(FdEntry::File(file)); + let fd2 = fd_table.open(FdEntry::Dir(dir)); + + let result = fd_table.renumber(fd1, fd2); + assert_eq!(result, Err(Error::BadFileDescriptor)); + + let result = fd_table.renumber(fd2, fd1); + assert_eq!(result, Err(Error::BadFileDescriptor)); + } + + #[test] + fn test_fdtable_node_refcount() { + let mut fd_table = FdTable::new(); + + // Open two file descriptors pointing to the same node + let file1 = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + let file2 = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + + let fd1 = fd_table.open(FdEntry::File(file1)); + let fd2 = fd_table.open(FdEntry::File(file2)); + + // Check node reference count + assert_eq!(fd_table.node_refcount().get(&1), Some(&2)); + + // Close one file descriptor + fd_table.close(fd1); + + // Check node reference count again + assert_eq!(fd_table.node_refcount().get(&1), Some(&1)); + + // Close the second file descriptor + fd_table.close(fd2); + + // Ensure the node reference count is now removed + assert!(fd_table.node_refcount().get(&1).is_none()); + } + + #[test] + fn test_fdtable_update() { + let mut fd_table = FdTable::new(); + + let file = File { + node: 1, + cursor: 0, + stat: FdStat::default(), + }; + let fd = fd_table.open(FdEntry::File(file)); + + let updated_file = File { + node: 2, + cursor: 0, + stat: FdStat::default(), + }; + fd_table.update(fd, FdEntry::File(updated_file)); + + // Ensure the updated entry is now in the table + let entry = fd_table.get(fd).unwrap(); + match entry { + FdEntry::File(file) => assert_eq!(file.node, 2), + _ => panic!("Expected a file entry"), + } + + // Ensure the node reference count was updated + assert!(fd_table.node_refcount().get(&1).is_none()); + assert_eq!(fd_table.node_refcount().get(&2), Some(&1)); + } +} diff --git a/src/runtime/file.rs b/src/runtime/file.rs index 48932db..0243ed1 100644 --- a/src/runtime/file.rs +++ b/src/runtime/file.rs @@ -45,26 +45,26 @@ impl File { let position = match whence { Whence::SET => { if delta < 0 { - return Err(Error::InvalidOffset); + return Err(Error::InvalidArgument); } delta as FileSize } Whence::CUR => { let back = if delta < 0 { - (-delta).try_into().map_err(|_| Error::InvalidOffset)? + (-delta).try_into().map_err(|_| Error::InvalidSeek)? } else { 0 }; let fwd = if delta >= 0 { delta as FileSize } else { 0 }; if back > self.cursor { - return Err(Error::InvalidOffset); + return Err(Error::InvalidSeek); } self.cursor + fwd - back } Whence::END => { - let back: FileSize = (-delta).try_into().map_err(|_| Error::InvalidOffset)?; + let back: FileSize = (-delta).try_into().map_err(|_| Error::InvalidSeek)?; if back > size { - return Err(Error::InvalidOffset); + return Err(Error::InvalidSeek); } size - back } @@ -130,7 +130,7 @@ impl File { pub fn truncate(&self, storage: &mut dyn Storage) -> Result<(), Error> { let mut metadata = storage.get_metadata(self.node)?; metadata.size = 0; - storage.put_metadata(self.node, metadata); + storage.put_metadata(self.node, &metadata)?; Ok(()) } } @@ -148,7 +148,7 @@ mod tests { fn seek_and_tell() { let mut fs = test_fs(); let fd = fs - .create_file(fs.root_fd(), "test", FdStat::default(), 0) + .create_open_file(fs.root_fd(), "test", FdStat::default(), 0) .unwrap(); let mut file = fs.get_test_file(fd); @@ -166,7 +166,7 @@ mod tests { assert_eq!(file.tell(), 1); let err = file.seek(-2, Whence::CUR, storage).unwrap_err(); - assert_eq!(err, Error::InvalidOffset); + assert_eq!(err, Error::InvalidSeek); assert_eq!(file.tell(), 1); let pos = file.seek(0, Whence::END, storage).unwrap(); @@ -178,7 +178,7 @@ mod tests { assert_eq!(file.tell(), 500); let err = file.seek(-1, Whence::SET, storage).unwrap_err(); - assert_eq!(err, Error::InvalidOffset); + assert_eq!(err, Error::InvalidArgument); assert_eq!(file.tell(), 500); let pos = file.seek(1001, Whence::SET, storage).unwrap(); @@ -190,7 +190,7 @@ mod tests { fn read_and_write_cursor() { let mut fs = test_fs(); let fd = fs - .create_file(fs.root_fd(), "test", FdStat::default(), 0) + .create_open_file(fs.root_fd(), "test", FdStat::default(), 0) .unwrap(); let mut file = fs.get_test_file(fd); @@ -213,7 +213,7 @@ mod tests { fn read_and_write_offset() { let mut fs = test_fs(); let fd = fs - .create_file(fs.root_fd(), "test", FdStat::default(), 0) + .create_open_file(fs.root_fd(), "test", FdStat::default(), 0) .unwrap(); let mut file = fs.get_test_file(fd); @@ -237,7 +237,7 @@ mod tests { fn read_and_write_small_and_big_buffer() { let mut fs = test_fs(); let fd = fs - .create_file(fs.root_fd(), "test", FdStat::default(), 0) + .create_open_file(fs.root_fd(), "test", FdStat::default(), 0) .unwrap(); let file = fs.get_test_file(fd); @@ -267,7 +267,7 @@ mod tests { for mut fs in [test_fs()] { //test_fs_setups("test") { let fd = fs - .open_or_create( + .open( fs.root_fd(), "test", FdStat::default(), @@ -300,7 +300,7 @@ mod tests { fn read_and_write_offset_vs_range() { for mut fs in test_fs_setups("test") { let fd = fs - .open_or_create( + .open( fs.root_fd(), "test", FdStat::default(), diff --git a/src/runtime/structure_helpers.rs b/src/runtime/structure_helpers.rs index 66bc170..8b6bbe9 100644 --- a/src/runtime/structure_helpers.rs +++ b/src/runtime/structure_helpers.rs @@ -42,7 +42,7 @@ fn find_node_with_index( } if part == ".." { - return Err(Error::InvalidFileName); + return Err(Error::InvalidArgument); } parent_dir_node = cur_node; @@ -101,9 +101,10 @@ pub fn create_hard_link( ) -> Result<(), Error> { // Check if the node exists already. let found = find_node(parent_dir_node, new_path, names_cache, storage); + match found { - Err(Error::NotFound) => {} - Ok(_) => return Err(Error::FileAlreadyExists), + Err(Error::BadFileDescriptor) => {} + Ok(_) => return Err(Error::FileExists), Err(err) => return Err(err), } @@ -117,11 +118,11 @@ pub fn create_hard_link( // only allow creating a hardlink on a folder if it is a part of renaming and another link will be removed if !is_renaming && metadata.file_type == FileType::Directory { - return Err(Error::InvalidFileType); + return Err(Error::OperationNotPermitted); } metadata.link_count += 1; - storage.put_metadata(node, metadata); + storage.put_metadata(node, &metadata)?; add_dir_entry(dir_node, node, leaf_name.as_bytes(), storage)?; @@ -136,7 +137,8 @@ pub fn create_dir_entry( ctime: u64, ) -> Result { if entry_type != FileType::Directory && entry_type != FileType::RegularFile { - return Err(Error::InvalidFileType); + // for now we only support files and folders (but not symbolic links) + return Err(Error::InvalidArgument); } let node = storage.new_node(); @@ -149,7 +151,7 @@ pub fn create_dir_entry( storage.put_metadata( node, - Metadata { + &Metadata { node, file_type: entry_type, link_count: 1, @@ -162,8 +164,9 @@ pub fn create_dir_entry( first_dir_entry: None, last_dir_entry: None, chunk_type, + maximum_size_allowed: None, }, - ); + )?; add_dir_entry(parent_dir_node, node, entry_name, storage)?; @@ -173,9 +176,10 @@ pub fn create_dir_entry( // create whole path if it doesn't exist // parent_node parent folder node // path full path -// leaf_type file type of the last path elemen (RegularFile or Directory) -// storage file system storage +// leaf_type file type of the last path element (RegularFile or Directory) +// is_exclusive if true, an error is returned if the node exists // ctime creation time to be used +// storage file system storage // returns the node of the last created folder part, return error if creation failed pub fn create_path<'a>( parent_node: Node, @@ -199,13 +203,13 @@ pub fn create_path<'a>( } if part == ".." { - return Err(Error::InvalidFileName); + return Err(Error::InvalidArgument); } if needs_folder_creation { // last_name contains the folder name to create if last_file_type != FileType::Directory { - return Err(Error::InvalidFileType); + return Err(Error::InvalidArgument); } // create new folder @@ -235,7 +239,7 @@ pub fn create_path<'a>( last_file_type = meta.file_type; } - Err(Error::NotFound) => { + Err(Error::BadFileDescriptor) => { needs_folder_creation = true; } Err(x) => { @@ -248,7 +252,7 @@ pub fn create_path<'a>( if needs_folder_creation { // last_name contains the folder name to create if last_file_type != FileType::Directory { - return Err(Error::InvalidFileType); + return Err(Error::InvalidArgument); } if let Some(leaf_type) = leaf_type { @@ -281,7 +285,7 @@ pub fn find_entry_index( } } - Err(Error::NotFound) + Err(Error::BadFileDescriptor) } // Add new directory entry @@ -325,7 +329,7 @@ pub fn add_dir_entry( } metadata.size += 1; - storage.put_metadata(parent_dir_node, metadata); + storage.put_metadata(parent_dir_node, &metadata)?; Ok(()) } @@ -345,16 +349,15 @@ pub fn rm_dir_entry( names_cache: &mut FilenameCache, storage: &mut dyn Storage, ) -> Result<(Node, Metadata), Error> { - // clear cache - // todo: clear concrete node, not the whole cache - names_cache.clear(); - let find_result = find_node_with_index(parent_dir_node, path, storage)?; let removed_dir_entry_node = find_result.node; + // remove node from name cache + names_cache.clear(); + if storage.is_mounted(removed_dir_entry_node) { - return Err(Error::CannotRemoveMountedMemoryFile); + return Err(Error::TextFileBusy); } let parent_dir_node = find_result.parent_dir; @@ -367,7 +370,8 @@ pub fn rm_dir_entry( match removed_metadata.file_type { FileType::Directory => { if expect_dir == Some(false) { - return Err(Error::ExpectedToRemoveFile); + // expected file + return Err(Error::IsDirectory); } if removed_metadata.link_count == 1 && removed_metadata.size > 0 { @@ -376,14 +380,15 @@ pub fn rm_dir_entry( } FileType::RegularFile | FileType::SymbolicLink => { if expect_dir == Some(true) { - return Err(Error::ExpectedToRemoveDirectory); + // expected directory + return Err(Error::NotADirectoryOrSymbolicLink); } } } if let Some(refcount) = node_refcount.get(&removed_metadata.node) { if *refcount > 0 && removed_metadata.link_count == 1 { - return Err(Error::CannotRemoveOpenedNode); + return Err(Error::TextFileBusy); } } @@ -417,13 +422,13 @@ pub fn rm_dir_entry( parent_dir_metadata.size -= 1; // update parent metadata - storage.put_metadata(parent_dir_node, parent_dir_metadata); + storage.put_metadata(parent_dir_node, &parent_dir_metadata)?; // remove the entry storage.rm_direntry(parent_dir_node, removed_entry_index); removed_metadata.link_count -= 1; - storage.put_metadata(removed_metadata.node, removed_metadata.clone()); + storage.put_metadata(removed_metadata.node, &removed_metadata)?; Ok((removed_dir_entry_node, removed_metadata)) } @@ -742,7 +747,7 @@ mod tests { 44u64, storage, ); - assert_eq!(res, Err(Error::InvalidFileType)); + assert_eq!(res, Err(Error::InvalidArgument)); let res = create_path( root_node, @@ -751,7 +756,7 @@ mod tests { 44u64, storage, ); - assert_eq!(res, Err(Error::InvalidFileType)); + assert_eq!(res, Err(Error::InvalidArgument)); let res = create_path( root_node, @@ -760,7 +765,7 @@ mod tests { 44u64, storage, ); - assert_eq!(res, Err(Error::InvalidFileType)); + assert_eq!(res, Err(Error::InvalidArgument)); let res = create_path( root_node, @@ -769,7 +774,7 @@ mod tests { 44u64, storage, ); - assert_eq!(res, Err(Error::InvalidFileType)); + assert_eq!(res, Err(Error::InvalidArgument)); } #[test] @@ -786,7 +791,7 @@ mod tests { 43u64, storage, ); - assert_eq!(res, Err(Error::InvalidFileType)); + assert_eq!(res, Err(Error::InvalidArgument)); } #[test] diff --git a/src/runtime/types.rs b/src/runtime/types.rs index 5385147..442203a 100644 --- a/src/runtime/types.rs +++ b/src/runtime/types.rs @@ -1,6 +1,9 @@ use bitflags::bitflags; use serde::{Deserialize, Serialize}; +// file descriptor +pub type Fd = u32; + #[derive(Copy, Clone, Debug)] pub struct FdStat { pub flags: FdFlags, @@ -50,6 +53,45 @@ pub enum ChunkType { V2 = 2, } +#[derive(Clone, Copy, Debug)] +pub enum Advice { + Normal = 0, + Sequential = 1, + Random = 2, + WillNeed = 3, + DontNeed = 4, + NoReuse = 5, +} + +impl TryFrom for Advice { + type Error = crate::error::Error; + + fn try_from(value: u8) -> Result { + match value { + 0 => Ok(Advice::Normal), + 1 => Ok(Advice::Sequential), + 2 => Ok(Advice::Random), + 3 => Ok(Advice::WillNeed), + 4 => Ok(Advice::DontNeed), + 5 => Ok(Advice::NoReuse), + _ => Err(crate::error::Error::InvalidArgument), + } + } +} + +impl From for u8 { + fn from(val: Advice) -> Self { + match val { + Advice::Normal => 0, + Advice::Sequential => 1, + Advice::Random => 2, + Advice::WillNeed => 3, + Advice::DontNeed => 4, + Advice::NoReuse => 5, + } + } +} + bitflags! { #[derive(Copy, Clone, Debug, PartialEq)] pub struct FdFlags: u16 { diff --git a/src/storage.rs b/src/storage.rs index dd62fa8..1a29254 100644 --- a/src/storage.rs +++ b/src/storage.rs @@ -11,7 +11,7 @@ mod allocator; mod chunk_iterator; pub mod dummy; mod journal; -mod metadata_cache; +mod metadata_provider; mod ptr_cache; pub mod stable; pub mod transient; @@ -45,7 +45,7 @@ pub trait Storage { // Get the metadata associated with the node. fn get_metadata(&self, node: Node) -> Result; // Update the metadata associated with the node. - fn put_metadata(&mut self, node: Node, metadata: Metadata); + fn put_metadata(&mut self, node: Node, metadata: &Metadata) -> Result<(), Error>; // Retrieve the DirEntry instance given the Node and DirEntryIndex. fn get_direntry(&self, node: Node, index: DirEntryIndex) -> Result; @@ -65,6 +65,9 @@ pub trait Storage { // Write file at the current file cursor, the cursor position will NOT be updated after reading. fn write(&mut self, node: Node, offset: FileSize, buf: &[u8]) -> Result; + // delete chunks to match the new file size specified + fn resize_file(&mut self, node: Node, new_size: FileSize) -> Result<(), Error>; + // remove all file chunks fn rm_file(&mut self, node: Node) -> Result<(), Error>; diff --git a/src/storage/allocator.rs b/src/storage/allocator.rs index b3f4f2d..5e73c7f 100644 --- a/src/storage/allocator.rs +++ b/src/storage/allocator.rs @@ -45,7 +45,7 @@ impl ChunkPtrAllocator { // possible accepted markers if b != *b"ALO1" && b != *b"FSA1" { - return Err(Error::InvalidMagicMarker); + return Err(Error::IllegalByteSequence); } if b == *b"ALO1" { @@ -94,6 +94,11 @@ impl ChunkPtrAllocator { self.write_u64(AVAILABLE_CHUNKS_LEN_IDX, new_len); } + #[cfg(test)] + pub fn get_current_max_ptr(&self) -> u64 { + self.read_u64(MAX_PTR_IDX) + } + fn get_next_max_ptr(&self) -> u64 { let ret = self.read_u64(MAX_PTR_IDX); @@ -153,7 +158,7 @@ impl ChunkPtrAllocator { .iter() .any(|size| *size as usize == new_size) { - return Err(Error::IncompatibleChunkSize); + return Err(Error::InvalidArgument); } // we can only set chunk size, if there are no chunks stored in the database, or the chunk size is not changed @@ -171,7 +176,7 @@ impl ChunkPtrAllocator { return Ok(()); } - Err(Error::IncompatibleChunkSize) + Err(Error::InvalidArgument) } #[inline] diff --git a/src/storage/chunk_iterator.rs b/src/storage/chunk_iterator.rs index 4df10c4..b0728c3 100644 --- a/src/storage/chunk_iterator.rs +++ b/src/storage/chunk_iterator.rs @@ -91,19 +91,23 @@ mod tests { fn create_file_with_size(size: FileSize, storage: &mut StableStorage) -> Node { let node = storage.new_node(); - storage.put_metadata( - node, - Metadata { + storage + .put_metadata( node, - file_type: FileType::RegularFile, - link_count: 1, - size, - times: Times::default(), - first_dir_entry: Some(42), - last_dir_entry: Some(24), - chunk_type: Some(storage.chunk_type()), - }, - ); + &Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size, + times: Times::default(), + first_dir_entry: Some(42), + last_dir_entry: Some(24), + chunk_type: Some(storage.chunk_type()), + maximum_size_allowed: None, + }, + ) + .unwrap(); + node } @@ -126,7 +130,7 @@ mod tests { file_size, storage.chunk_size() as FileSize, &mut storage.ptr_cache, - &mut storage.v2_chunk_ptr, + &mut storage.v2_filechunk.v2_chunk_ptr, ); let res_vec: Vec<_> = iterator.collect(); @@ -152,7 +156,7 @@ mod tests { file_size, storage.chunk_size() as FileSize, &mut storage.ptr_cache, - &mut storage.v2_chunk_ptr, + &mut storage.v2_filechunk.v2_chunk_ptr, ); let res_vec: Vec<_> = iterator.collect(); @@ -181,7 +185,7 @@ mod tests { file_size, storage.chunk_size() as FileSize, &mut storage.ptr_cache, - &mut storage.v2_chunk_ptr, + &mut storage.v2_filechunk.v2_chunk_ptr, ); let res_vec: Vec<_> = iterator.collect(); @@ -210,7 +214,7 @@ mod tests { file_size, storage.chunk_size() as FileSize, &mut storage.ptr_cache, - &mut storage.v2_chunk_ptr, + &mut storage.v2_filechunk.v2_chunk_ptr, ); let res_vec: Vec<_> = iterator.collect(); diff --git a/src/storage/dummy.rs b/src/storage/dummy.rs index a9b1931..d402ded 100644 --- a/src/storage/dummy.rs +++ b/src/storage/dummy.rs @@ -36,7 +36,7 @@ impl Storage for DummyStorage { panic!("Not supported") } - fn put_metadata(&mut self, _node: Node, _metadata: Metadata) { + fn put_metadata(&mut self, _node: Node, _metadata: &Metadata) -> Result<(), Error> { panic!("Not supported") } @@ -114,6 +114,10 @@ impl Storage for DummyStorage { fn flush(&mut self, _node: Node) { panic!("Not supported") } + + fn resize_file(&mut self, _node: Node, _new_size: FileSize) -> Result<(), Error> { + panic!("Not supported") + } } #[cfg(test)] @@ -127,19 +131,22 @@ mod tests { fn put_metadata_panic() { let mut storage = DummyStorage::new(); let node = storage.new_node(); - storage.put_metadata( - node, - Metadata { + storage + .put_metadata( node, - file_type: FileType::RegularFile, - link_count: 1, - size: 10, - times: Times::default(), - first_dir_entry: Some(42), - last_dir_entry: Some(24), - chunk_type: None, - }, - ) + &Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size: 10, + times: Times::default(), + first_dir_entry: Some(42), + last_dir_entry: Some(24), + chunk_type: None, + maximum_size_allowed: None, + }, + ) + .unwrap(); } #[test] diff --git a/src/storage/journal.rs b/src/storage/journal.rs index 8f931b1..a64f347 100644 --- a/src/storage/journal.rs +++ b/src/storage/journal.rs @@ -1,42 +1,26 @@ use ic_stable_structures::{memory_manager::VirtualMemory, Memory}; -use crate::{ - error::Error, - runtime::structure_helpers::{read_obj, write_obj}, -}; - -use super::types::{Metadata, Node}; - -// index containing cached metadata -const MOUNTED_META_PTR: u64 = 16; +use crate::error::Error; +#[allow(dead_code)] pub struct CacheJournal { journal: VirtualMemory, - - mounted_node: Node, - mounted_meta: Metadata, } // The cache stored in stable memory for some information that has to be stored between upgrades. impl CacheJournal { + #[allow(dead_code)] pub fn new(journal: VirtualMemory) -> Result, Error> { - let cache_journal = if journal.size() == 0 { + if journal.size() == 0 { journal.grow(1); // write the magic marker let b = [b'F', b'S', b'J', b'1', 0, 0, 0, 0]; journal.write(0, &b); - let mut cache_journal = CacheJournal { - journal, - mounted_node: u64::MAX, - mounted_meta: Metadata::default(), - }; + let cache_journal = CacheJournal { journal }; - // reset mounted meta node - cache_journal.reset_mounted_meta(); - - cache_journal + Ok(cache_journal) } else { // check the marker let mut b = [0u8; 4]; @@ -44,62 +28,16 @@ impl CacheJournal { // accepted marker if b != *b"FSJ1" { - return Err(Error::InvalidMagicMarker); + return Err(Error::IllegalByteSequence); } - let mut cache_journal = CacheJournal { - journal, - mounted_node: u64::MAX, - mounted_meta: Metadata::default(), - }; + let cache_journal = CacheJournal { journal }; // init local cache variables - read_obj( - &cache_journal.journal, - MOUNTED_META_PTR, - &mut cache_journal.mounted_node, - ); - read_obj( - &cache_journal.journal, - MOUNTED_META_PTR + 8, - &mut cache_journal.mounted_meta, - ); - - cache_journal - }; - - Ok(cache_journal) - } - - pub fn read_mounted_meta_node(&self) -> Option { - let ret = self.mounted_node; + //... - //read_obj(&self.journal, MOUNTED_META_PTR, &mut ret); - if ret == u64::MAX { - return None; + Ok(cache_journal) } - - Some(ret) - } - - pub fn read_mounted_meta(&self, meta: &mut Metadata) { - *meta = self.mounted_meta.clone(); - - //read_obj(&self.journal, MOUNTED_META_PTR + 8, meta); - } - - pub fn reset_mounted_meta(&mut self) { - self.mounted_node = u64::MAX; - self.mounted_meta = Metadata::default(); - - write_obj(&self.journal, MOUNTED_META_PTR, &(u64::MAX as Node)); - } - - pub fn write_mounted_meta(&mut self, node: &Node, meta: &Metadata) { - self.mounted_node = *node; - self.mounted_meta = (*meta).clone(); - - write_obj(&self.journal, MOUNTED_META_PTR, &(*node, (*meta).clone())); } } @@ -107,51 +45,10 @@ impl CacheJournal { mod tests { use ic_stable_structures::memory_manager::{MemoryId, MemoryManager}; - use crate::storage::types::Node; - use crate::test_utils::new_vector_memory; use super::*; - #[test] - fn cache_journal_metadata_roundtrip() { - let mem = new_vector_memory(); - let memory_manager = MemoryManager::init(mem); - let journal_memory = memory_manager.get(MemoryId::new(1)); - let mut journal = CacheJournal::new(journal_memory).unwrap(); - - let node: Node = 123; - let meta = Metadata { - node: 123, - file_type: crate::storage::types::FileType::RegularFile, - link_count: 1, - size: 1234, - times: crate::storage::types::Times { - accessed: 48, - modified: 388, - created: 34, - }, - first_dir_entry: None, - last_dir_entry: Some(876), - chunk_type: None, - }; - - let mut node2 = 0; - let mut meta2 = Metadata::default(); - - assert_ne!(node, node2); - assert_ne!(meta, meta2); - - journal.write_mounted_meta(&node, &meta); - - node2 = journal.read_mounted_meta_node().unwrap(); - - journal.read_mounted_meta(&mut meta2); - - assert_eq!(node, node2); - assert_eq!(meta, meta2); - } - #[test] fn fsj1_marker_is_written() { let mem = new_vector_memory(); @@ -194,50 +91,4 @@ mod tests { assert!(res.is_err()); } - - #[test] - fn initial_node_value() { - let mem = new_vector_memory(); - let memory_manager = MemoryManager::init(mem); - let journal_memory = memory_manager.get(MemoryId::new(1)); - let journal = CacheJournal::new(journal_memory).unwrap(); - - assert_eq!(journal.read_mounted_meta_node(), None); - } - - #[test] - fn updated_node_value_after_upgrade() { - let mem = new_vector_memory(); - let memory_manager = MemoryManager::init(mem); - let journal_memory = memory_manager.get(MemoryId::new(1)); - let mut journal = CacheJournal::new(journal_memory).unwrap(); - - assert_eq!(journal.read_mounted_meta_node(), None); - - let meta = Metadata { - node: 123, - file_type: crate::storage::types::FileType::RegularFile, - link_count: 1, - size: 1234, - times: crate::storage::types::Times { - accessed: 48, - modified: 388, - created: 34, - }, - first_dir_entry: None, - last_dir_entry: Some(876), - chunk_type: None, - }; - - journal.write_mounted_meta(&123, &meta); - - let journal = CacheJournal::new(memory_manager.get(MemoryId::new(1))).unwrap(); - - assert_eq!(journal.read_mounted_meta_node(), Some(123)); - - let mut meta2 = Metadata::default(); - journal.read_mounted_meta(&mut meta2); - - assert_eq!(meta, meta2); - } } diff --git a/src/storage/metadata_cache.rs b/src/storage/metadata_cache.rs deleted file mode 100644 index a1c2e4f..0000000 --- a/src/storage/metadata_cache.rs +++ /dev/null @@ -1,193 +0,0 @@ -use std::collections::HashMap; - -use super::types::{Metadata, Node}; -use std::cell::RefCell; -use std::rc::Rc; - -const CACHE_CAPACITY: usize = 100; - -#[derive(Debug)] -pub(crate) struct MetadataCache { - meta: Rc>>, -} - -impl MetadataCache { - pub fn new() -> MetadataCache { - let meta: Rc>> = - Rc::new(RefCell::new(HashMap::with_capacity(CACHE_CAPACITY))); - - MetadataCache { meta } - } - - // add new cache meta - pub fn update(&self, node: Node, new_meta: &Metadata) { - let mut meta = (*self.meta).borrow_mut(); - - if meta.len() + 1 > CACHE_CAPACITY { - meta.clear(); - } - - meta.insert(node, new_meta.clone()); - } - - // clear cache completely - pub fn clear(&self) { - let mut meta = (*self.meta).borrow_mut(); - - meta.clear(); - } - - pub fn get(&self, node: Node) -> std::option::Option { - let meta = (*self.meta).borrow(); - - meta.get(&node).cloned() - } -} - -#[cfg(test)] -mod tests { - use crate::{ - fs::ChunkType, - storage::types::{FileType, Times}, - }; - - use super::*; - - #[test] - fn cache_initialization() { - let cache = MetadataCache::new(); - assert_eq!( - cache.meta.borrow().len(), - 0, - "Cache should be empty on initialization" - ); - } - - #[test] - fn cache_update_and_get() { - let cache = MetadataCache::new(); - let node = 1 as Node; - let metadata = Metadata { - node, - file_type: FileType::RegularFile, - link_count: 1, - size: 45, - times: Times { - accessed: 0, - modified: 0, - created: 0, - }, - first_dir_entry: None, - last_dir_entry: None, - chunk_type: Some(ChunkType::V2), - }; - - cache.update(node, &metadata); - - // Check if the metadata can be retrieved correctly - let retrieved = cache.get(node); - assert_eq!( - retrieved, - Some(metadata), - "Retrieved metadata should match inserted metadata" - ); - } - - #[test] - fn cache_clear() { - let cache = MetadataCache::new(); - let node = 1 as Node; - - let metadata = Metadata { - node, - file_type: FileType::RegularFile, - link_count: 1, - size: 45, - times: Times { - accessed: 0, - modified: 0, - created: 0, - }, - first_dir_entry: None, - last_dir_entry: None, - chunk_type: Some(ChunkType::V2), - }; - - cache.update(node, &metadata); - cache.clear(); - - // Cache should be empty after clear - assert_eq!( - cache.meta.borrow().len(), - 0, - "Cache should be empty after clearing" - ); - assert_eq!( - cache.get(node), - None, - "Metadata should be None after cache is cleared" - ); - } - - #[test] - fn cache_eviction_when_capacity_exceeded() { - let cache = MetadataCache::new(); - - // Fill the cache to its capacity - for i in 0..CACHE_CAPACITY { - let node = i as Node; - - let metadata = Metadata { - node, - file_type: FileType::RegularFile, - link_count: 1, - size: 45, - times: Times { - accessed: 0, - modified: 0, - created: 0, - }, - first_dir_entry: None, - last_dir_entry: None, - chunk_type: Some(ChunkType::V2), - }; - - cache.update(node, &metadata); - } - - assert_eq!( - cache.meta.borrow().len(), - CACHE_CAPACITY, - "Cache should have CACHE_CAPACITY entries" - ); - - // Add one more item to trigger eviction (if implemented) - let extra_node = 1000 as Node; - - let extra_metadata = Metadata { - node: extra_node, - file_type: FileType::RegularFile, - link_count: 1, - size: 475, - times: Times { - accessed: 0, - modified: 0, - created: 0, - }, - first_dir_entry: None, - last_dir_entry: None, - chunk_type: Some(ChunkType::V2), - }; - - cache.update(extra_node, &extra_metadata); - - assert!( - cache.meta.borrow().len() <= CACHE_CAPACITY, - "Cache should not exceed CACHE_CAPACITY" - ); - assert!( - cache.get(extra_node).is_some(), - "Extra node should be in the cache after eviction" - ); - } -} diff --git a/src/storage/metadata_provider.rs b/src/storage/metadata_provider.rs new file mode 100644 index 0000000..f5a8d00 --- /dev/null +++ b/src/storage/metadata_provider.rs @@ -0,0 +1,381 @@ +use std::collections::HashMap; + +use super::allocator::ChunkPtrAllocator; +use super::stable::{V2FileChunks, ROOT_NODE}; +use super::types::{FileChunk, FileChunkIndex, FileChunkPtr, FileType, Times}; +use super::types::{Metadata, Node}; +use crate::fs::FileSize; +use crate::runtime::structure_helpers::{grow_memory, read_obj, write_obj}; +use crate::storage::ptr_cache::PtrCache; +use crate::storage::types::ZEROES; +use ic_stable_structures::memory_manager::VirtualMemory; +use ic_stable_structures::BTreeMap; +use ic_stable_structures::Memory; +use std::cell::RefCell; +use std::rc::Rc; + +const CACHE_CAPACITY: usize = 1000; + +// custom file chunk containing metadata. +pub const METADATA_CHUNK_INDEX: u32 = u32::MAX - 1; +// custom file chunk containing metadata for the mounted drives. +pub const MOUNTED_METADATA_CHUNK_INDEX: u32 = u32::MAX - 2; + +// reserve 1024 bytes for future, for storing metadata +pub const MAX_META_SIZE: usize = 1024; + +type MetadataCacheMap = HashMap)>; + +#[derive(Debug)] +pub(crate) struct MetadataCache { + meta: Rc>, +} + +impl MetadataCache { + pub fn new() -> MetadataCache { + let meta: Rc> = + Rc::new(RefCell::new(HashMap::with_capacity(CACHE_CAPACITY))); + + MetadataCache { meta } + } + + // add new cache meta + pub fn update(&self, node: Node, new_meta: &Metadata, new_ptr: Option) { + let mut meta = (*self.meta).borrow_mut(); + + if meta.len() + 1 > CACHE_CAPACITY { + meta.clear(); + } + + meta.insert(node, (new_meta.clone(), new_ptr)); + } + + pub fn remove(&self, node: Node) { + let mut meta = (*self.meta).borrow_mut(); + meta.remove(&node); + } + + pub fn get(&self, node: Node) -> std::option::Option<(Metadata, Option)> { + let meta = (*self.meta).borrow(); + meta.get(&node).cloned() + } +} + +pub(crate) struct MetadataProvider { + // only use it with non-mounted files. This reduces metadata search overhead, when the same file is read. + meta_cache: MetadataCache, + + // only use it with mounted files. This reduces metadata search overhead, when the same file is read. + mounted_meta_cache: MetadataCache, + + // data about one file or a folder such as creation time, file size, associated chunk type, etc. + metadata: BTreeMap>, + // The metadata of the mounted memory files. + // * We store this separately from regular file metadata because the same node IDs can be reused for the related files. + // * We need this metadata because we want the information on the mounted files (such as file size) to survive between canister upgrades. + mounted_meta: BTreeMap>, +} + +impl MetadataProvider { + pub fn new( + meta_mem: VirtualMemory, + mounted_meta_mem: VirtualMemory, + ) -> MetadataProvider { + MetadataProvider { + meta_cache: MetadataCache::new(), + mounted_meta_cache: MetadataCache::new(), + metadata: BTreeMap::init(meta_mem), + mounted_meta: BTreeMap::init(mounted_meta_mem), + } + } + + pub(crate) fn remove_metadata( + &mut self, + node: Node, + ptr_cache: &mut PtrCache, + filechunk: &mut BTreeMap<(Node, FileChunkIndex), FileChunk, VirtualMemory>, + v2_chunk_ptr: &mut BTreeMap<(Node, FileChunkIndex), FileChunkPtr, VirtualMemory>, + v2_allocator: &mut ChunkPtrAllocator, + ) { + // remove metadata + self.mounted_meta.remove(&node); + self.metadata.remove(&node); + + self.meta_cache.remove(node); + self.mounted_meta_cache.remove(node); + + ptr_cache.clear(); + + // removing file data chunks as well + let range = (node, 0)..(node + 1, 0); + + let mut chunks: Vec<(Node, FileChunkIndex)> = Vec::new(); + + for (k, _v) in filechunk.range(range) { + chunks.push(k); + } + + for (nd, idx) in chunks.into_iter() { + assert!(nd == node); + filechunk.remove(&(node, idx)); + } + + // delete v2 chunks + + // delete all nodes, including file contents and metadata chunks + let range = (node, 0)..(node + 1, 0); + + let mut chunks: Vec<(Node, FileChunkIndex)> = Vec::new(); + + for (k, _v) in v2_chunk_ptr.range(range) { + chunks.push((k.0, k.1)); + } + + for (nd, idx) in chunks.into_iter() { + assert!(nd == node); + + let removed = v2_chunk_ptr.remove(&(node, idx)); + + if let Some(removed) = removed { + v2_allocator.free(removed); + } + } + } + + fn load_chunk_meta(&self, v2_chunks: &VirtualMemory, ptr: FileChunkPtr) -> Metadata { + let mut meta = Metadata::default(); + read_obj(v2_chunks, ptr, &mut meta); + meta + } + + fn store_chunk_meta(&self, v2_chunks: &VirtualMemory, ptr: FileChunkPtr, meta: &Metadata) { + write_obj(v2_chunks, ptr, meta); + } + + // try to get metadata and the data pointer, or return None if not found. + pub(crate) fn get_metadata( + &self, + node: Node, + is_mounted: bool, + v2_chunk_ptr: &BTreeMap<(Node, FileChunkIndex), FileChunkPtr, VirtualMemory>, + v2_chunks: &VirtualMemory, + ) -> Option<(Metadata, Option)> { + let (meta_index, meta_storage, meta_cache) = if is_mounted { + ( + MOUNTED_METADATA_CHUNK_INDEX, + &self.mounted_meta, + &self.mounted_meta_cache, + ) + } else { + (METADATA_CHUNK_INDEX, &self.metadata, &self.meta_cache) + }; + + // try to get meta from cache + let meta_rec = meta_cache.get(node); + + if let Some(meta_rec) = meta_rec { + return Some((meta_rec.0.clone(), meta_rec.1)); + } + + // meta not found in cache, try to get it from the file chunks + let meta_ptr: Option = v2_chunk_ptr.get(&(node, meta_index)); + + if let Some(meta_ptr) = meta_ptr { + // the chunk pointer is known, now read the contents + let meta = self.load_chunk_meta(v2_chunks, meta_ptr); + + // update cache + meta_cache.update(node, &meta, Some(meta_ptr)); + + return Some((meta, Some(meta_ptr))); + } + + // meta not found in chunks, try to get it from the storage + let meta_found = meta_storage.get(&node); + + if meta_found.is_none() { + // if root node is not found on the new file system, just return the generated one. + if node == ROOT_NODE { + let metadata = Metadata { + node: ROOT_NODE, + file_type: FileType::Directory, + link_count: 1, + size: 0, + times: Times::default(), + first_dir_entry: None, + last_dir_entry: None, + chunk_type: None, + maximum_size_allowed: None, + }; + + return Some((metadata, None)); + } + } + + // return None, if no metadata was found under given node + let metadata = meta_found?; + + // update cache + meta_cache.update(node, &metadata, None); + + Some((metadata, None)) + } + + // put new metadata value, while overwriting the existing record, at this point the metadata should already be validated + pub(crate) fn put_metadata( + &mut self, + node: u64, + is_mounted: bool, + metadata: &Metadata, + meta_ptr: Option, + v2: &mut V2FileChunks, + ) { + assert_eq!(node, metadata.node, "Node does not match metadata.node!"); + + let (meta_index, meta_cache) = if is_mounted { + (MOUNTED_METADATA_CHUNK_INDEX, &self.mounted_meta_cache) + } else { + (METADATA_CHUNK_INDEX, &self.meta_cache) + }; + + // create a new meta pointer if it was not + let meta_ptr = if let Some(meta_ptr) = meta_ptr { + meta_ptr + } else { + let meta_ptr = v2.v2_allocator.allocate(); + + v2.v2_chunk_ptr.insert((node, meta_index), meta_ptr); + + // prefill new memory with 0 (we want to avoid undefined memory) + grow_memory( + &v2.v2_chunks, + meta_ptr as FileSize + MAX_META_SIZE as FileSize, + ); + + v2.v2_chunks.write(meta_ptr, &ZEROES[0..MAX_META_SIZE]); + + meta_ptr + }; + + // store metadata into chunk + self.store_chunk_meta(&v2.v2_chunks, meta_ptr, metadata); + + // update cache + meta_cache.update(node, metadata, Some(meta_ptr)); + } +} + +#[cfg(test)] +mod tests { + use crate::{ + fs::ChunkType, + storage::types::{FileType, Times}, + }; + + use super::*; + + #[test] + fn cache_initialization() { + let cache = MetadataCache::new(); + assert_eq!( + cache.meta.borrow().len(), + 0, + "Cache should be empty on initialization" + ); + } + + #[test] + fn cache_update_and_get() { + let cache = MetadataCache::new(); + let node = 1 as Node; + let metadata = Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size: 45, + times: Times { + accessed: 0, + modified: 0, + created: 0, + }, + first_dir_entry: None, + last_dir_entry: None, + chunk_type: Some(ChunkType::V2), + maximum_size_allowed: None, + }; + + cache.update(node, &metadata, Some(1024)); + + // Check if the metadata can be retrieved correctly + let retrieved = cache.get(node); + assert_eq!( + retrieved, + Some((metadata, Some(1024))), + "Retrieved metadata should match inserted metadata" + ); + } + + #[test] + fn cache_eviction_when_capacity_exceeded() { + let cache = MetadataCache::new(); + + // Fill the cache to its capacity + for i in 0..CACHE_CAPACITY { + let node = i as Node; + + let metadata = Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size: 45, + times: Times { + accessed: 0, + modified: 0, + created: 0, + }, + first_dir_entry: None, + last_dir_entry: None, + chunk_type: Some(ChunkType::V2), + maximum_size_allowed: None, + }; + + cache.update(node, &metadata, Some(1024)); + } + + assert_eq!( + cache.meta.borrow().len(), + CACHE_CAPACITY, + "Cache should have CACHE_CAPACITY entries" + ); + + // Add one more item to trigger eviction (if implemented) + let extra_node = 1000 as Node; + + let extra_metadata = Metadata { + node: extra_node, + file_type: FileType::RegularFile, + link_count: 1, + size: 475, + times: Times { + accessed: 0, + modified: 0, + created: 0, + }, + first_dir_entry: None, + last_dir_entry: None, + chunk_type: Some(ChunkType::V2), + maximum_size_allowed: None, + }; + + cache.update(extra_node, &extra_metadata, Some(1024)); + + assert!( + cache.meta.borrow().len() <= CACHE_CAPACITY, + "Cache should not exceed CACHE_CAPACITY" + ); + assert!( + cache.get(extra_node).is_some(), + "Extra node should be in the cache after eviction" + ); + } +} diff --git a/src/storage/ptr_cache.rs b/src/storage/ptr_cache.rs index fc95a79..ff3ed07 100644 --- a/src/storage/ptr_cache.rs +++ b/src/storage/ptr_cache.rs @@ -1,6 +1,6 @@ use std::collections::HashMap; -use super::types::{FileChunkIndex, FileChunkPtr, Node}; +use super::types::{FileChunkIndex, FileChunkPtr, Node, MAX_FILE_CHUNK_INDEX}; use ic_stable_structures::memory_manager::VirtualMemory; use ic_stable_structures::BTreeMap; @@ -50,6 +50,11 @@ impl PtrCache { ) { let to_index = to_index.min(from_index + MAX_CACHE_CHUNKS); let to_index = to_index.max(from_index + MIN_CACHE_CHUNKS); + let to_index = to_index.min(MAX_FILE_CHUNK_INDEX); + + if from_index >= to_index { + return; + } let range = (node, from_index)..(node, to_index); diff --git a/src/storage/stable.rs b/src/storage/stable.rs index 207ba60..e25195e 100644 --- a/src/storage/stable.rs +++ b/src/storage/stable.rs @@ -1,12 +1,16 @@ use std::{collections::HashMap, ops::Range}; +use crate::storage::types::ZEROES; use ic_cdk::api::stable::WASM_PAGE_SIZE_IN_BYTES; use ic_stable_structures::{ memory_manager::{MemoryId, MemoryManager, VirtualMemory}, BTreeMap, Cell, Memory, }; -use crate::storage::ptr_cache::CachedChunkPtr; +use crate::{ + runtime::structure_helpers::{read_obj, write_obj}, + storage::ptr_cache::CachedChunkPtr, +}; use crate::{ error::Error, @@ -20,17 +24,16 @@ use crate::{ use super::{ allocator::ChunkPtrAllocator, chunk_iterator::ChunkV2Iterator, - journal::CacheJournal, - metadata_cache::MetadataCache, + metadata_provider::MetadataProvider, ptr_cache::PtrCache, types::{ DirEntry, DirEntryIndex, FileChunk, FileChunkIndex, FileChunkPtr, FileSize, FileType, - Header, Metadata, Node, Times, FILE_CHUNK_SIZE_V1, MAX_FILE_CHUNK_SIZE_V2, + Header, Metadata, Node, Times, FILE_CHUNK_SIZE_V1, MAX_FILE_CHUNK_INDEX, MAX_FILE_SIZE, }, Storage, }; -const ROOT_NODE: Node = 0; +pub const ROOT_NODE: Node = 0; const FS_VERSION: u32 = 1; const DEFAULT_FIRST_MEMORY_INDEX: u8 = 229; @@ -41,11 +44,13 @@ const MAX_MEMORY_INDEX: u8 = 254; // the number of memory indices used by the file system (currently 8 plus some reserved ids) const MEMORY_INDEX_COUNT: u8 = 10; -const ZEROES: [u8; MAX_FILE_CHUNK_SIZE_V2] = [0u8; MAX_FILE_CHUNK_SIZE_V2]; +// index containing cached metadata (deprecated) +const MOUNTED_META_PTR: u64 = 16; enum StorageMemoryIdx { Header = 0, Metadata = 1, + DirEntries = 2, FileChunksV1 = 3, @@ -77,36 +82,35 @@ struct StorageMemories { } #[repr(C)] -pub struct StableStorage { - // some static-sized filesystem data, contains version number and the next node id. - header: Cell>, - // data about one file or a folder such as creation time, file size, associated chunk type, etc. - metadata: BTreeMap>, - // information about the directory structure. - direntry: BTreeMap<(Node, DirEntryIndex), DirEntry, VirtualMemory>, - // actual file data stored in chunks insize BTreeMap. - filechunk: BTreeMap<(Node, FileChunkIndex), FileChunk, VirtualMemory>, - - // The metadata of the mounted memory files. - // * We store this separately from regular file metadata because the same node IDs can be reused for the related files. - // * We need this metadata because we want the information on the mounted files (such as file size) to survive between canister upgrades. - mounted_meta: BTreeMap>, - - // the alternative storage to file chunks V1, we only store pointers, hence no serialization overhead +pub struct V2FileChunks { + // the file chunk storage V2, we only store pointers to reduce serialization overheads. pub(crate) v2_chunk_ptr: BTreeMap<(Node, FileChunkIndex), FileChunkPtr, VirtualMemory>, // the actual storage of the chunks, // * we can read and write small fragments of data, no need to read and write in chunk-sized blocks // * the pointers in the BTreeMap (Node, FileChunkIndex) -> FileChunkPtr are static, // this allows caching to avoid chunk search overheads. - v2_chunks: VirtualMemory, + pub(crate) v2_chunks: VirtualMemory, // keeps information on the chunks currently available. // it can be setup to work with different chunk sizes. // 4K - the same as chunks V1, 16K - the default, 64K - the biggest chunk size available. // the increased chunk size reduces the number of BTree insertions, and increases the performanc. - v2_allocator: ChunkPtrAllocator, + pub(crate) v2_allocator: ChunkPtrAllocator, +} + +#[repr(C)] +pub struct StableStorage { + // some static-sized filesystem data, contains version number and the next node id. + header: Cell>, + // information about the directory structure. + direntry: BTreeMap<(Node, DirEntryIndex), DirEntry, VirtualMemory>, + // actual file data stored in chunks insize BTreeMap. + filechunk: BTreeMap<(Node, FileChunkIndex), FileChunk, VirtualMemory>, + + // file data stored in V2 file chunks + pub(crate) v2_filechunk: V2FileChunks, - // extra cache for storing information between upgrades. - cache_journal: CacheJournal, + // helper object managing file metadata access of all types + meta_provider: MetadataProvider, // It is not used, but is needed to keep memories alive. _memory_manager: Option>, @@ -119,9 +123,6 @@ pub struct StableStorage { // chunk pointer cache. This cache reduces chunk search overhead when reading a file, // or writing a file over existing data. (the new files still need insert new pointers into the treemap, hence it is rather slow) pub(crate) ptr_cache: PtrCache, - - // only use it with non-mounted files. This reduces metadata search overhead, when the same file is . - meta_cache: MetadataCache, } impl StableStorage { @@ -201,6 +202,59 @@ impl StableStorage { Self::new_with_custom_memories(memories) } + // support deprecated storage, recover stored mounted file metadata + // we have to use a custom node here, + fn init_size_from_cache_journal(&mut self, journal: &VirtualMemory) { + // re-define old Metadata type for correct reading + #[derive(Clone, Default, PartialEq)] + pub struct MetadataLegacy { + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub first_dir_entry: Option, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + // try recover stored mounted metadata (if any) + if journal.size() > 0 { + let mut mounted_node = 0u64; + let mut mounted_meta = MetadataLegacy::default(); + + read_obj(journal, MOUNTED_META_PTR, &mut mounted_node); + + read_obj(journal, MOUNTED_META_PTR + 8, &mut mounted_meta); + + let meta_read = Metadata { + node: mounted_meta.node, + file_type: FileType::RegularFile, + link_count: mounted_meta.link_count, + size: mounted_meta.size, + times: mounted_meta.times, + first_dir_entry: mounted_meta.first_dir_entry, + last_dir_entry: mounted_meta.last_dir_entry, + chunk_type: mounted_meta.chunk_type, + maximum_size_allowed: None, + }; + + if mounted_node != u64::MAX && mounted_node == mounted_meta.node { + // immediately store the recovered metadata + self.meta_provider.put_metadata( + mounted_node, + true, + &meta_read, + None, + &mut self.v2_filechunk, + ); + + // reset cached metadata + write_obj(journal, MOUNTED_META_PTR, &(u64::MAX as Node)); + } + } + } + fn new_with_custom_memories(memories: StorageMemories) -> Self { let default_header_value = Header { version: FS_VERSION, @@ -208,57 +262,44 @@ impl StableStorage { }; let v2_allocator = ChunkPtrAllocator::new(memories.v2_allocator_memory).unwrap(); - let cache_journal = CacheJournal::new(memories.cache_journal).unwrap(); + let ptr_cache = PtrCache::new(); + let v2_chunk_ptr = BTreeMap::init(memories.v2_chunk_ptr_memory); + + let meta_provider = + MetadataProvider::new(memories.metadata_memory, memories.mounted_meta_memory); let mut result = Self { header: Cell::init(memories.header_memory, default_header_value).unwrap(), - metadata: BTreeMap::init(memories.metadata_memory), direntry: BTreeMap::init(memories.direntry_memory), filechunk: BTreeMap::init(memories.filechunk_memory), - mounted_meta: BTreeMap::init(memories.mounted_meta_memory), - v2_chunk_ptr: BTreeMap::init(memories.v2_chunk_ptr_memory), - v2_chunks: memories.v2_chunks_memory, - v2_allocator, - - cache_journal, + v2_filechunk: V2FileChunks { + v2_chunk_ptr, + v2_chunks: memories.v2_chunks_memory, + v2_allocator, + }, // transient runtime data _memory_manager: None, active_mounts: HashMap::new(), + // default chunk type is V2 chunk_type: ChunkType::V2, - ptr_cache: PtrCache::new(), - meta_cache: MetadataCache::new(), + ptr_cache, + + meta_provider, }; + // init mounted drive + result.init_size_from_cache_journal(&memories.cache_journal); + let version = result.header.get().version; if version != FS_VERSION { panic!("Unsupported file system version"); } - match result.get_metadata(ROOT_NODE) { - Ok(_) => {} - Err(Error::NotFound) => { - let metadata = Metadata { - node: ROOT_NODE, - file_type: FileType::Directory, - link_count: 1, - size: 0, - times: Times::default(), - first_dir_entry: None, - last_dir_entry: None, - chunk_type: None, - }; - result.put_metadata(ROOT_NODE, metadata); - } - Err(err) => { - unreachable!("Unexpected error while loading root metadata: {:?}", err); - } - } - result } @@ -312,7 +353,7 @@ impl StableStorage { last_address, self.chunk_size() as FileSize, &mut self.ptr_cache, - &mut self.v2_chunk_ptr, + &mut self.v2_filechunk.v2_chunk_ptr, ); let write_iter: Vec<_> = write_iter.collect(); @@ -335,23 +376,25 @@ impl StableStorage { ptr } else { // insert new chunk - let ptr = self.v2_allocator.allocate(); + let ptr = self.v2_filechunk.v2_allocator.allocate(); - grow_memory(&self.v2_chunks, ptr + chunk_size as FileSize); + grow_memory(&self.v2_filechunk.v2_chunks, ptr + chunk_size as FileSize); // fill new chunk with zeroes (appart from the area that will be overwritten) // fill before written content - self.v2_chunks.write(ptr, &ZEROES[0..chunk_offset as usize]); + self.v2_filechunk + .v2_chunks + .write(ptr, &ZEROES[0..chunk_offset as usize]); // fill after written content - self.v2_chunks.write( + self.v2_filechunk.v2_chunks.write( ptr + chunk_offset + to_write as FileSize, &ZEROES[0..(chunk_size - chunk_offset as usize - to_write as usize)], ); // register new chunk pointer - self.v2_chunk_ptr.insert((node, index), ptr); + self.v2_filechunk.v2_chunk_ptr.insert((node, index), ptr); // self.ptr_cache @@ -362,7 +405,9 @@ impl StableStorage { // growing here should not be required as the grow is called during // grow_memory(&self.v2_chunks, chunk_ptr + offset + buf.len() as FileSize); - self.v2_chunks.write(chunk_ptr + chunk_offset, write_buf); + self.v2_filechunk + .v2_chunks + .write(chunk_ptr + chunk_offset, write_buf); chunk_offset = 0; size_written += to_write; @@ -471,7 +516,7 @@ impl StableStorage { file_size, chunk_size as FileSize, &mut self.ptr_cache, - &mut self.v2_chunk_ptr, + &mut self.v2_filechunk.v2_chunk_ptr, ); for ((nd, _idx), cached_chunk) in read_iter { @@ -491,7 +536,9 @@ impl StableStorage { let read_buf = &mut buf[size_read as usize..size_read as usize + to_read as usize]; if let CachedChunkPtr::ChunkExists(cptr) = cached_chunk { - self.v2_chunks.read(cptr + chunk_offset, read_buf); + self.v2_filechunk + .v2_chunks + .read(cptr + chunk_offset, read_buf); } else { // fill read buffer with 0 read_buf.iter_mut().for_each(|m| *m = 0) @@ -505,16 +552,6 @@ impl StableStorage { Ok(size_read) } - fn flush_mounted_meta(&mut self) { - let node = self.cache_journal.read_mounted_meta_node(); - - if let Some(node) = node { - let mut meta: Metadata = Metadata::default(); - self.cache_journal.read_mounted_meta(&mut meta); - self.mounted_meta.insert(node, meta); - } - } - fn use_v2(&mut self, metadata: &Metadata, node: u64) -> bool { // decide if we use v2 chunks for reading/writing let use_v2 = match metadata.chunk_type { @@ -525,7 +562,11 @@ impl StableStorage { None => { if metadata.size > 0 { // try to find any v2 node, othersize use v1 - let ptr = self.v2_chunk_ptr.range((node, 0)..(node + 1, 0)).next(); + let ptr = self + .v2_filechunk + .v2_chunk_ptr + .range((node, 0)..(node + 1, 0)) + .next(); ptr.is_some() } else { @@ -535,6 +576,91 @@ impl StableStorage { }; use_v2 } + + fn validate_metadata_update( + old_meta: Option<&Metadata>, + new_meta: &Metadata, + ) -> Result<(), Error> { + if let Some(old_meta) = old_meta { + if old_meta.node != new_meta.node { + return Err(Error::IllegalByteSequence); + } + } + + if let Some(max_size) = new_meta.maximum_size_allowed { + if new_meta.size > max_size { + return Err(Error::FileTooLarge); + } + } + + Ok(()) + } + + fn resize_file_internal(&mut self, node: Node, new_size: FileSize) -> Result<(), Error> { + if self.is_mounted(node) { + // for the mounted node we only update file size in the metadata (no need to delete chunks) + return Ok(()); + } + + // delete v1 chunks + let chunk_size = FILE_CHUNK_SIZE_V1; + + let first_deletable_index = (new_size.div_ceil(chunk_size as FileSize)) as FileChunkIndex; + + let range = (node, first_deletable_index)..(node + 1, 0); + + let mut chunks: Vec<(Node, FileChunkIndex)> = Vec::new(); + + for (k, _v) in self.filechunk.range(range) { + chunks.push(k); + } + + for (nd, idx) in chunks.into_iter() { + assert!(nd == node); + self.filechunk.remove(&(node, idx)); + } + + // fill with zeros the last chunk memory above the file size + if first_deletable_index > 0 { + let offset = new_size as FileSize % chunk_size as FileSize; + + self.write_filechunk_v1( + node, + first_deletable_index - 1, + offset, + &ZEROES[0..(chunk_size - offset as usize)], + ); + } + + // delete v2 chunks + + let chunk_size = self.chunk_size(); + + let first_deletable_index = (new_size.div_ceil(chunk_size as FileSize)) as FileChunkIndex; + + let range = (node, first_deletable_index)..(node, MAX_FILE_CHUNK_INDEX); + let mut chunks: Vec<(Node, FileChunkIndex)> = Vec::new(); + for (k, _v) in self.v2_filechunk.v2_chunk_ptr.range(range) { + chunks.push(k); + } + + for (nd, idx) in chunks.into_iter() { + assert!(nd == node); + let removed = self.v2_filechunk.v2_chunk_ptr.remove(&(node, idx)); + + if let Some(removed) = removed { + self.v2_filechunk.v2_allocator.free(removed); + } + } + + // fill with zeros the last chunk memory above the file size + if first_deletable_index > 0 { + let offset = new_size as FileSize % chunk_size as FileSize; + self.write_chunks_v2(node, new_size, &ZEROES[0..(chunk_size - offset as usize)])?; + } + + Ok(()) + } } impl Storage for StableStorage { @@ -563,52 +689,58 @@ impl Storage for StableStorage { // Get the metadata associated with the node. fn get_metadata(&self, node: Node) -> Result { - if self.is_mounted(node) { - if self.cache_journal.read_mounted_meta_node() == Some(node) { - let mut meta = Metadata::default(); - self.cache_journal.read_mounted_meta(&mut meta); + self.meta_provider + .get_metadata( + node, + self.is_mounted(node), + &self.v2_filechunk.v2_chunk_ptr, + &self.v2_filechunk.v2_chunks, + ) + .map(|x| x.0) + .ok_or(Error::BadFileDescriptor) + } - return Ok(meta); - } + // Update the metadata associated with the node. + fn put_metadata(&mut self, node: Node, metadata: &Metadata) -> Result<(), Error> { + let is_mounted = self.is_mounted(node); - self.mounted_meta.get(&node).ok_or(Error::NotFound) - } else { - let meta = self.meta_cache.get(node); + let meta_rec = self.meta_provider.get_metadata( + node, + is_mounted, + &self.v2_filechunk.v2_chunk_ptr, + &self.v2_filechunk.v2_chunks, + ); - if let Some(meta) = meta { - return Ok(meta); - } + let (old_meta, meta_ptr) = match meta_rec.as_ref() { + Some((m, p)) => (Some(m), *p), + None => (None, None), + }; - let meta = self.metadata.get(&node).ok_or(Error::NotFound); + Self::validate_metadata_update(old_meta, metadata)?; - if let Ok(ref meta) = meta { - self.meta_cache.update(node, meta); + if let Some(old_meta) = old_meta { + // if the size was reduced, we need to delete the file chunks above the file size + if metadata.size < old_meta.size { + self.resize_file_internal(node, metadata.size)?; } - - meta } - } - - // Update the metadata associated with the node. - fn put_metadata(&mut self, node: Node, metadata: Metadata) { - assert_eq!(node, metadata.node, "Node does not match medatada.node!"); - if self.is_mounted(node) { - // flush changes if the last node was different - if self.cache_journal.read_mounted_meta_node() != Some(node) { - self.flush_mounted_meta(); - } + self.meta_provider.put_metadata( + node, + is_mounted, + metadata, + meta_ptr, + &mut self.v2_filechunk, + ); - self.cache_journal.write_mounted_meta(&node, &metadata) - } else { - self.meta_cache.update(node, &metadata); - self.metadata.insert(node, metadata); - } + Ok(()) } // Retrieve the DirEntry instance given the Node and DirEntryIndex. fn get_direntry(&self, node: Node, index: DirEntryIndex) -> Result { - self.direntry.get(&(node, index)).ok_or(Error::NotFound) + self.direntry + .get(&(node, index)) + .ok_or(Error::BadFileDescriptor) } // Update or insert the DirEntry instance given the Node and DirEntryIndex. @@ -625,7 +757,8 @@ impl Storage for StableStorage { fn read(&mut self, node: Node, offset: FileSize, buf: &mut [u8]) -> Result { let metadata = self.get_metadata(node)?; - let file_size = metadata.size; + let max_size = metadata.maximum_size_allowed.unwrap_or(MAX_FILE_SIZE); + let file_size = metadata.size.min(max_size); if offset >= file_size { return Ok(0); @@ -657,6 +790,12 @@ impl Storage for StableStorage { fn write(&mut self, node: Node, offset: FileSize, buf: &[u8]) -> Result { let mut metadata = self.get_metadata(node)?; + let max_size = metadata.maximum_size_allowed.unwrap_or(MAX_FILE_SIZE); + + if offset + buf.len() as FileSize > max_size { + return Err(Error::FileTooLarge); + } + let written_size = if let Some(memory) = self.get_mounted_memory(node) { self.write_mounted(memory, offset, buf); @@ -691,67 +830,42 @@ impl Storage for StableStorage { let end = offset + buf.len() as FileSize; if end > metadata.size { metadata.size = end; - self.put_metadata(node, metadata); + self.put_metadata(node, &metadata)?; } Ok(written_size) } - // - fn rm_file(&mut self, node: Node) -> Result<(), Error> { - if self.is_mounted(node) { - return Err(Error::CannotRemoveMountedMemoryFile); - } + fn resize_file(&mut self, node: Node, new_size: FileSize) -> Result<(), Error> { + let mut meta = self.get_metadata(node)?; - // delete v1 chunks - let range = (node, 0)..(node + 1, 0); - let mut chunks: Vec<(Node, FileChunkIndex)> = Vec::new(); - for (k, _v) in self.filechunk.range(range) { - chunks.push(k); - } - - for (nd, idx) in chunks.into_iter() { - assert!(nd == node); - self.filechunk.remove(&(node, idx)); - } - - // delete v2 chunks - let range = (node, 0)..(node + 1, 0); - let mut chunks: Vec<(Node, FileChunkIndex)> = Vec::new(); - for (k, _v) in self.v2_chunk_ptr.range(range) { - chunks.push(k); - } + meta.size = new_size; - for (nd, idx) in chunks.into_iter() { - assert!(nd == node); - let removed = self.v2_chunk_ptr.remove(&(node, idx)); + self.put_metadata(node, &meta) + } - if let Some(removed) = removed { - self.v2_allocator.free(removed); - } + // + fn rm_file(&mut self, node: Node) -> Result<(), Error> { + if self.is_mounted(node) { + return Err(Error::DeviceOrResourceBusy); } - // clear cache - self.ptr_cache.clear(); - - // remove metadata - self.mounted_meta.remove(&node); - self.metadata.remove(&node); + self.resize_file(node, 0)?; - let mounted_meta_node = self.cache_journal.read_mounted_meta_node(); - if mounted_meta_node == Some(node) { - // reset cached mounted metadata - self.cache_journal.reset_mounted_meta() - } - - self.meta_cache.clear(); + self.meta_provider.remove_metadata( + node, + &mut self.ptr_cache, + &mut self.filechunk, + &mut self.v2_filechunk.v2_chunk_ptr, + &mut self.v2_filechunk.v2_allocator, + ); Ok(()) } fn mount_node(&mut self, node: Node, memory: Box) -> Result<(), Error> { if self.is_mounted(node) { - return Err(Error::MemoryFileIsMountedAlready); + return Err(Error::DeviceOrResourceBusy); } // do extra meta preparation @@ -768,7 +882,7 @@ impl Storage for StableStorage { file_meta.size = 0; // update mounted metadata - self.put_metadata(node, file_meta); + self.put_metadata(node, &file_meta)?; }; Ok(()) @@ -777,7 +891,7 @@ impl Storage for StableStorage { fn unmount_node(&mut self, node: Node) -> Result, Error> { let memory = self.active_mounts.remove(&node); - memory.ok_or(Error::MemoryFileIsNotMounted) + memory.ok_or(Error::NoSuchDevice) } fn is_mounted(&self, node: Node) -> bool { @@ -819,7 +933,7 @@ impl Storage for StableStorage { self.mount_node(node, memory)?; - self.put_metadata(node, meta); + self.put_metadata(node, &meta)?; Ok(()) } @@ -855,7 +969,7 @@ impl Storage for StableStorage { remainder -= to_read; } - self.put_metadata(node, meta); + self.put_metadata(node, &meta)?; self.mount_node(node, memory)?; @@ -863,11 +977,13 @@ impl Storage for StableStorage { } fn set_chunk_size(&mut self, chunk_size: ChunkSize) -> Result<(), Error> { - self.v2_allocator.set_chunk_size(chunk_size as usize) + self.v2_filechunk + .v2_allocator + .set_chunk_size(chunk_size as usize) } fn chunk_size(&self) -> usize { - self.v2_allocator.chunk_size() + self.v2_filechunk.v2_allocator.chunk_size() } fn set_chunk_type(&mut self, chunk_type: ChunkType) { @@ -879,7 +995,7 @@ impl Storage for StableStorage { } fn flush(&mut self, _node: Node) { - self.flush_mounted_meta(); + // nothing to flush, the system immediately stores data on write } } @@ -896,19 +1012,22 @@ mod tests { fn read_and_write_filechunk() { let mut storage = StableStorage::new(DefaultMemoryImpl::default()); let node = storage.new_node(); - storage.put_metadata( - node, - Metadata { + storage + .put_metadata( node, - file_type: FileType::RegularFile, - link_count: 1, - size: 10, - times: Times::default(), - first_dir_entry: Some(42), - last_dir_entry: Some(24), - chunk_type: Some(storage.chunk_type()), - }, - ); + &Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size: 10, + times: Times::default(), + first_dir_entry: Some(42), + last_dir_entry: Some(24), + chunk_type: Some(storage.chunk_type()), + maximum_size_allowed: None, + }, + ) + .unwrap(); let metadata = storage.get_metadata(node).unwrap(); assert_eq!(metadata.node, node); assert_eq!(metadata.file_type, FileType::RegularFile); @@ -945,4 +1064,322 @@ mod tests { assert_eq!(direntry.next_entry, Some(42)); assert_eq!(direntry.prev_entry, Some(24)); } + + fn new_file(storage: &mut StableStorage) -> Node { + let node = storage.new_node(); + + storage + .put_metadata( + node, + &Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size: 0, + times: Times::default(), + first_dir_entry: None, + last_dir_entry: None, + chunk_type: Some(storage.chunk_type()), + maximum_size_allowed: None, + }, + ) + .unwrap(); + + node + } + + #[test] + fn read_beyond_file_size() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + + let node = new_file(&mut storage); + + storage.write(node, 0, b"hello").unwrap(); + + let mut buf = [0u8; 10]; + let bytes_read = storage.read(node, 3, &mut buf).unwrap(); + + assert_eq!(bytes_read, 2); + assert_eq!(&buf[..2], b"lo"); + + assert_eq!(buf[2..], [0; 8]); + } + + #[test] + fn switch_chunk_types() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + + storage.set_chunk_type(ChunkType::V1); + + let node_v1 = new_file(&mut storage); + + storage.write(node_v1, 0, b"v1_data").unwrap(); + + storage.set_chunk_type(ChunkType::V2); + + let node_v2 = new_file(&mut storage); + + // Write data + storage.write(node_v2, 0, b"v2_data").unwrap(); + + // Confirm reads + let mut buf_v1 = [0u8; 7]; + storage.read(node_v1, 0, &mut buf_v1).unwrap(); + assert_eq!(&buf_v1, b"v1_data"); + let meta = storage.get_metadata(node_v1).unwrap(); + assert_eq!(meta.chunk_type.unwrap(), ChunkType::V1); + + let mut buf_v2 = [0u8; 7]; + storage.read(node_v2, 0, &mut buf_v2).unwrap(); + assert_eq!(&buf_v2, b"v2_data"); + let meta = storage.get_metadata(node_v2).unwrap(); + assert_eq!(meta.chunk_type.unwrap(), ChunkType::V2); + } + + #[test] + fn resize_file_shrink_and_grow() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + let node = new_file(&mut storage); + + storage.write(node, 0, b"1234567890").unwrap(); + let mut buf = [0u8; 10]; + storage.read(node, 0, &mut buf).unwrap(); + assert_eq!(&buf, b"1234567890"); + + // Shrink to 5 bytes + storage.resize_file(node, 5).unwrap(); + + let meta = storage.get_metadata(node).unwrap(); + assert_eq!(meta.size, 5); // Check the metadata reflects new size + + // Reading the file now + let mut buf_small = [0u8; 10]; + let bytes_read = storage.read(node, 0, &mut buf_small).unwrap(); + assert_eq!(bytes_read, 5); + assert_eq!(&buf_small[..5], b"12345"); + assert_eq!(&buf_small[5..], [0; 5]); + + // check zero fill + let mut meta = storage.get_metadata(node).unwrap(); + meta.size = 10; + storage.put_metadata(node, &meta).unwrap(); + + // Confirm new bytes are zeroed or remain uninitialized, depending on design + let mut buf_grow = [0u8; 10]; + storage.read(node, 0, &mut buf_grow).unwrap(); + // First 5 bytes should remain "12345", rest must be zero: + assert_eq!(&buf_grow[..5], b"12345"); + assert_eq!(&buf_grow[5..], [0; 5]); + } + + #[test] + fn resize_file_shrink_deletes_v2_chunks() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + let node = new_file(&mut storage); + + let chunk_size = storage.chunk_size() as FileSize; + + // write something into the second chunk + storage.write(node, chunk_size + 4, b"1234567890").unwrap(); + + // write something into the first chunk + storage.write(node, 4, b"1234567890").unwrap(); + + let mut buf = [0u8; 10]; + // read second chunk + storage.read(node, chunk_size + 9, &mut buf).unwrap(); + + assert_eq!(&buf, b"67890\0\0\0\0\0"); + + let chunks: Vec<_> = storage + .v2_filechunk + .v2_chunk_ptr + .range((node, 0)..(node, 5)) + .collect(); + assert_eq!(chunks.len(), 2); + + // Shrink to 5 bytes + storage.resize_file(node, 5).unwrap(); + + let meta = storage.get_metadata(node).unwrap(); + + // only one chunk should be present + assert_eq!(meta.size, 5); // Check the metadata reflects new size + + let chunks: Vec<_> = storage + .v2_filechunk + .v2_chunk_ptr + .range((node, 0)..(node, 5)) + .collect(); + assert_eq!(chunks.len(), 1); + + // for 0 size, all chunks have to be deleted + storage.resize_file(node, 0).unwrap(); + let chunks: Vec<_> = storage + .v2_filechunk + .v2_chunk_ptr + .range((node, 0)..(node, 5)) + .collect(); + assert_eq!(chunks.len(), 0); + } + + #[test] + fn resize_file_shrink_deletes_v1_chunks() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + storage.set_chunk_type(ChunkType::V1); + + let node = new_file(&mut storage); + + let chunk_size = FILE_CHUNK_SIZE_V1 as FileSize; + + // write something into the second chunk + storage.write(node, chunk_size + 4, b"1234567890").unwrap(); + + // write something into the first chunk + storage.write(node, 4, b"1234567890").unwrap(); + + let mut buf = [0u8; 10]; + // read second chunk + storage.read(node, chunk_size + 9, &mut buf).unwrap(); + + assert_eq!(&buf, b"67890\0\0\0\0\0"); + + let chunks: Vec<_> = storage.filechunk.range((node, 0)..(node, 5)).collect(); + assert_eq!(chunks.len(), 2); + + // Shrink to 5 bytes + storage.resize_file(node, 5).unwrap(); + + let meta = storage.get_metadata(node).unwrap(); + + // only one chunk should be present + assert_eq!(meta.size, 5); // Check the metadata reflects new size + + let chunks: Vec<_> = storage.filechunk.range((node, 0)..(node, 5)).collect(); + assert_eq!(chunks.len(), 1); + + // for 0 size, all chunks have to be deleted + storage.resize_file(node, 0).unwrap(); + let chunks: Vec<_> = storage.filechunk.range((node, 0)..(node, 5)).collect(); + assert_eq!(chunks.len(), 0); + } + + #[test] + fn remove_file_chunks_v2() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + + let chunk_size = storage.chunk_size() as FileSize; + + // some other files present + let node_other = new_file(&mut storage); + storage.write(node_other, 0, b"some data").unwrap(); + + let node = new_file(&mut storage); + + // write into 5 chunks + 1 metadata chunk, expect to find 6 chunks + storage.write(node, 0, b"some data").unwrap(); + storage.write(node, chunk_size, b"some data").unwrap(); + storage.write(node, chunk_size * 2, b"some data").unwrap(); + // write into two chunks with one call + storage + .write(node, chunk_size * 5 - 2, b"some data") + .unwrap(); + + // some other files present + let node_other2 = new_file(&mut storage); + storage.write(node_other2, 0, b"some data").unwrap(); + + // check chunk count + let chunks: Vec<_> = storage + .v2_filechunk + .v2_chunk_ptr + .range((node, 0)..(node + 1, 0)) + .collect(); + + // chunks of the given node + assert_eq!(chunks.len(), 6); + + // check the allocator is also holding 6 chunks of the main file, and 4 chunks from the two other files + assert_eq!( + storage.v2_filechunk.v2_allocator.get_current_max_ptr(), + (6 + 4) * chunk_size + ); + + // Remove file + storage.rm_file(node).unwrap(); + + // Confirm reading fails or returns NotFound + let mut buf = [0u8; 9]; + let res = storage.read(node, 0, &mut buf); + assert!(matches!(res, Err(Error::BadFileDescriptor))); + + // Confirm metadata is removed + let meta_res = storage.get_metadata(node); + assert!(matches!(meta_res, Err(Error::BadFileDescriptor))); + + // check there are no chunks left after deleting the node + let chunks: Vec<_> = storage + .v2_filechunk + .v2_chunk_ptr + .range((node, 0)..(node + 1, 0)) + .collect(); + + assert_eq!(chunks.len(), 0); + } + + #[test] + fn remove_file_chunks_v1() { + let mut storage = StableStorage::new(DefaultMemoryImpl::default()); + storage.set_chunk_type(ChunkType::V1); + + let chunk_size = FILE_CHUNK_SIZE_V1 as FileSize; + + // some other files present + let node_other = new_file(&mut storage); + storage.write(node_other, 0, b"some data").unwrap(); + + let node = new_file(&mut storage); + + // write into 5 chunks + storage.write(node, 0, b"some data").unwrap(); + storage.write(node, chunk_size, b"some data").unwrap(); + storage.write(node, chunk_size * 2, b"some data").unwrap(); + // write into two chunks with one call + storage + .write(node, chunk_size * 5 - 2, b"some data") + .unwrap(); + + // some other files present + let node_other2 = new_file(&mut storage); + storage.write(node_other2, 0, b"some data").unwrap(); + + // check chunk count + let chunks: Vec<_> = storage.filechunk.range((node, 0)..(node + 1, 0)).collect(); + + // chunks of the given node + assert_eq!(chunks.len(), 5); + + // check the allocator is holding three chunks for 3 stored metadata + assert_eq!( + storage.v2_filechunk.v2_allocator.get_current_max_ptr(), + storage.chunk_size() as FileSize * 3 + ); + + // Remove file + storage.rm_file(node).unwrap(); + + // Confirm reading fails or returns NotFound + let mut buf = [0u8; 9]; + let res = storage.read(node, 0, &mut buf); + assert!(matches!(res, Err(Error::BadFileDescriptor))); + + // Confirm metadata is removed + let meta_res = storage.get_metadata(node); + assert!(matches!(meta_res, Err(Error::BadFileDescriptor))); + + // check there are no chunks left after deleting the node + let chunks: Vec<_> = storage.filechunk.range((node, 0)..(node + 1, 0)).collect(); + + assert_eq!(chunks.len(), 0); + } } diff --git a/src/storage/transient.rs b/src/storage/transient.rs index 7591a50..0c3c684 100644 --- a/src/storage/transient.rs +++ b/src/storage/transient.rs @@ -10,7 +10,7 @@ use crate::{ storage::{ types::{ DirEntry, DirEntryIndex, FileChunk, FileChunkIndex, FileSize, FileType, Metadata, Node, - Times, + Times, ZEROES, }, Storage, }, @@ -51,7 +51,9 @@ impl TransientStorage { first_dir_entry: None, last_dir_entry: None, chunk_type: None, + maximum_size_allowed: None, }; + let mut result = Self { header: Header { version: 1, @@ -64,7 +66,11 @@ impl TransientStorage { mounted_meta: Default::default(), active_mounts: Default::default(), }; - result.put_metadata(ROOT_NODE, metadata); + + result + .put_metadata(ROOT_NODE, &metadata) + .expect("Failed to create metadata"); + result } @@ -86,6 +92,25 @@ impl TransientStorage { entry.bytes[offset as usize..offset as usize + buf.len()].copy_from_slice(buf) } } + + fn validate_metadata_update( + old_meta: Option<&Metadata>, + new_meta: &Metadata, + ) -> Result<(), Error> { + if let Some(max_size) = new_meta.maximum_size_allowed { + if new_meta.size > max_size { + return Err(Error::FileTooLarge); + } + } + + if let Some(old_meta) = old_meta { + if old_meta.node != new_meta.node { + return Err(Error::InvalidArgument); + } + } + + Ok(()) + } } impl Storage for TransientStorage { @@ -109,26 +134,41 @@ impl Storage for TransientStorage { // Get the metadata associated with the node. fn get_metadata(&self, node: Node) -> Result { let meta = if self.is_mounted(node) { - self.mounted_meta.get(&node).ok_or(Error::NotFound)? + self.mounted_meta + .get(&node) + .ok_or(Error::BadFileDescriptor)? } else { - self.metadata.get(&node).ok_or(Error::NotFound)? + self.metadata.get(&node).ok_or(Error::BadFileDescriptor)? }; Ok(meta.clone()) } // Update the metadata associated with the node. - fn put_metadata(&mut self, node: Node, metadata: Metadata) { - if self.is_mounted(node) { - self.mounted_meta.insert(node, metadata); + fn put_metadata(&mut self, node: Node, metadata: &Metadata) -> Result<(), Error> { + let meta_storage = if self.is_mounted(node) { + &mut self.mounted_meta + } else { + &mut self.metadata + }; + + if let Some(existing) = meta_storage.get(&node) { + Self::validate_metadata_update(Some(existing), metadata)?; } else { - self.metadata.insert(node, metadata); + Self::validate_metadata_update(None, metadata)?; } + + meta_storage.insert(node, metadata.clone()); + + Ok(()) } // Retrieve the DirEntry instance given the Node and DirEntryIndex. fn get_direntry(&self, node: Node, index: DirEntryIndex) -> Result { - let value = self.direntry.get(&(node, index)).ok_or(Error::NotFound)?; + let value = self + .direntry + .get(&(node, index)) + .ok_or(Error::BadFileDescriptor)?; Ok(value.clone()) } @@ -225,11 +265,10 @@ impl Storage for TransientStorage { Ok(size_read) } - // - fn rm_file(&mut self, node: Node) -> Result<(), Error> { - if self.is_mounted(node) { - return Err(Error::CannotRemoveMountedMemoryFile); - } + fn resize_file(&mut self, node: Node, new_size: FileSize) -> Result<(), Error> { + let chunk_size = FILE_CHUNK_SIZE_V1; + + let first_deletable_index = (new_size.div_ceil(chunk_size as FileSize)) as FileChunkIndex; let range = (node, 0)..(node + 1, 0); @@ -244,6 +283,28 @@ impl Storage for TransientStorage { self.filechunk.remove(&(node, idx)); } + // fill with zeros the last chunk memory above the file size + if first_deletable_index > 0 { + let offset = new_size as FileSize % chunk_size as FileSize; + + self.write_filechunk( + node, + first_deletable_index - 1, + offset, + &ZEROES[0..(chunk_size - offset as usize)], + ); + } + + Ok(()) + } + + fn rm_file(&mut self, node: Node) -> Result<(), Error> { + if self.is_mounted(node) { + return Err(Error::DeviceOrResourceBusy); + } + + self.resize_file(node, 0)?; + // remove metadata self.mounted_meta.remove(&node); self.metadata.remove(&node); @@ -253,11 +314,15 @@ impl Storage for TransientStorage { fn mount_node(&mut self, node: Node, memory: Box) -> Result<(), Error> { if self.is_mounted(node) { - return Err(Error::MemoryFileIsMountedAlready); + return Err(Error::DeviceOrResourceBusy); } // do extra meta preparation - let mut meta = self.metadata.get(&node).ok_or(Error::NotFound)?.clone(); + let mut meta = self + .metadata + .get(&node) + .ok_or(Error::BadFileDescriptor)? + .clone(); self.active_mounts.insert(node, memory); @@ -278,7 +343,7 @@ impl Storage for TransientStorage { fn unmount_node(&mut self, node: Node) -> Result, Error> { let memory = self.active_mounts.remove(&node); - memory.ok_or(Error::MemoryFileIsNotMounted) + memory.ok_or(Error::NoSuchDevice) } fn is_mounted(&self, node: Node) -> bool { @@ -320,7 +385,7 @@ impl Storage for TransientStorage { self.mount_node(node, memory)?; - self.put_metadata(node, meta); + self.put_metadata(node, &meta)?; Ok(()) } @@ -353,7 +418,7 @@ impl Storage for TransientStorage { remainder -= to_read; } - self.put_metadata(node, meta); + self.put_metadata(node, &meta)?; self.mount_node(node, memory)?; @@ -363,6 +428,13 @@ impl Storage for TransientStorage { fn write(&mut self, node: Node, offset: FileSize, buf: &[u8]) -> Result { let mut metadata = self.get_metadata(node)?; let end = offset + buf.len() as FileSize; + + if let Some(max_size) = metadata.maximum_size_allowed { + if end > max_size { + return Err(Error::FileTooLarge); + } + } + let chunk_infos = get_chunk_infos(offset, end, FILE_CHUNK_SIZE_V1); let mut written_size = 0; for chunk in chunk_infos.into_iter() { @@ -377,7 +449,7 @@ impl Storage for TransientStorage { if end > metadata.size { metadata.size = end; - self.put_metadata(node, metadata) + self.put_metadata(node, &metadata)?; } Ok(written_size as FileSize) @@ -413,19 +485,22 @@ mod tests { fn read_and_write_filechunk() { let mut storage = TransientStorage::default(); let node = storage.new_node(); - storage.put_metadata( - node, - Metadata { + storage + .put_metadata( node, - file_type: FileType::RegularFile, - link_count: 1, - size: 10, - times: Times::default(), - first_dir_entry: None, - last_dir_entry: None, - chunk_type: Some(storage.chunk_type()), - }, - ); + &Metadata { + node, + file_type: FileType::RegularFile, + link_count: 1, + size: 10, + times: Times::default(), + first_dir_entry: None, + last_dir_entry: None, + chunk_type: Some(storage.chunk_type()), + maximum_size_allowed: None, + }, + ) + .unwrap(); storage.write(node, 0, &[42; 10]).unwrap(); let mut buf = [0; 10]; storage.read(node, 0, &mut buf).unwrap(); diff --git a/src/storage/types.rs b/src/storage/types.rs index a3d502f..4fc5c37 100644 --- a/src/storage/types.rs +++ b/src/storage/types.rs @@ -9,6 +9,12 @@ pub const MAX_FILE_CHUNK_SIZE_V2: usize = 65536; pub const MAX_FILE_NAME: usize = 255; +// maximum chunk index. (reserve last 10 chunks for custom needs) +pub const MAX_FILE_CHUNK_INDEX: u32 = u32::MAX - 10; + +// maximum file size supported by the file system. +pub const MAX_FILE_SIZE: u64 = (MAX_FILE_CHUNK_INDEX as u64) * FILE_CHUNK_SIZE_V1 as u64; + // The unique identifier of a node, which can be a file or a directory. // Also known as inode in WASI and other file systems. pub type Node = u64; @@ -22,7 +28,10 @@ pub type FileChunkIndex = u32; // The address in memory where the V2 chunk is stored. pub type FileChunkPtr = u64; -// A handle used for writing files in chunks +// An array filled with 0 used to fill memory with 0 via copy. +pub static ZEROES: [u8; MAX_FILE_CHUNK_SIZE_V2] = [0u8; MAX_FILE_CHUNK_SIZE_V2]; + +// A handle used for writing files in chunks. #[derive(Debug, PartialEq, Eq)] pub(crate) struct ChunkHandle { pub index: FileChunkIndex, @@ -81,7 +90,7 @@ impl ic_stable_structures::Storable for Header { const BOUND: Bound = Bound::Unbounded; } -// Contains metadata of a node. +#[repr(C, align(8))] #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)] pub struct Metadata { pub node: Node, @@ -92,16 +101,7 @@ pub struct Metadata { pub first_dir_entry: Option, pub last_dir_entry: Option, pub chunk_type: Option, -} - -// Contains metadata that is stored together with the file chunks (for faster access and updates of the file size) -#[repr(C)] -#[derive(Clone, Debug, Default)] -pub struct FileMetadata { - pub node: Node, - pub size: FileSize, - pub times: Times, - pub file_type: FileType, + pub maximum_size_allowed: Option, } impl ic_stable_structures::Storable for Metadata { @@ -121,10 +121,10 @@ impl ic_stable_structures::Storable for Metadata { // The type of a node. #[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Serialize, Deserialize)] pub enum FileType { - Directory, + Directory = 3, #[default] - RegularFile, - SymbolicLink, + RegularFile = 4, + SymbolicLink = 7, } impl TryFrom for FileType { @@ -135,7 +135,7 @@ impl TryFrom for FileType { 3 => Ok(FileType::Directory), 4 => Ok(FileType::RegularFile), 7 => Ok(FileType::SymbolicLink), - _ => Err(Error::InvalidFileType), + _ => Err(Error::InvalidArgument), } } } @@ -202,7 +202,7 @@ impl FileName { pub fn new(name: &[u8]) -> Result { let len = name.len(); if len > MAX_FILE_NAME { - return Err(Error::NameTooLong); + return Err(Error::FilenameTooLong); } let mut bytes = [0; MAX_FILE_NAME]; bytes[0..len].copy_from_slice(name); diff --git a/src/test_utils.rs b/src/test_utils.rs index 9542419..05dc62e 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -91,7 +91,7 @@ pub fn write_text_file( ) -> Result<(), Error> { use crate::fs::{FdStat, OpenFlags}; - let file_fd = fs.open_or_create(parent_fd, path, FdStat::default(), OpenFlags::CREATE, 0)?; + let file_fd = fs.open(parent_fd, path, FdStat::default(), OpenFlags::CREATE, 0)?; write_text_fd(fs, file_fd, content, times) } @@ -151,7 +151,7 @@ pub fn read_text_file( use crate::fs::{DstBuf, FdStat, OpenFlags}; let fd = fs - .open_or_create(parent_fd, path, FdStat::default(), OpenFlags::empty(), 0) + .open(parent_fd, path, FdStat::default(), OpenFlags::empty(), 0) .unwrap(); let mut content = (0..size).map(|_| ".").collect::(); @@ -174,11 +174,13 @@ pub fn read_text_file( #[cfg(test)] mod test_env { - use crate::runtime::fd::Fd; + use crate::fs::FileSize; use crate::runtime::types::DstBuf; + use crate::runtime::types::Fd; use crate::runtime::types::FdStat; use crate::runtime::types::OpenFlags; use crate::runtime::types::Whence; + use crate::storage::types::FileType; use crate::test_utils::FileSystem; use crate::test_utils::SrcBuf; use crate::test_utils::StableStorage; @@ -203,7 +205,7 @@ mod test_env { //v0.4 //let storage = StableStorage::new_with_memory_manager(&memory_manager, 200u8); //v0.5, v0.6 ... - let mut storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210u8); + let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210u8); // set chunk version to V1 //storage.set_chunk_type(storage::stable::ChunkType::V1); @@ -224,30 +226,6 @@ mod test_env { }; } - fn file_size(filename: String) -> usize { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); - - let dir = fs.root_fd(); - - let fd = fs - .open_or_create( - dir, - filename.as_str(), - FdStat::default(), - OpenFlags::empty(), - 0, - ) - .unwrap(); - - let meta = fs.metadata(fd).unwrap(); - - let size = meta.size; - - size as usize - }) - } - thread_local! { static BUFFER: RefCell>> = const { RefCell::new(None) }; } @@ -322,98 +300,6 @@ mod test_env { }) } - pub fn read_buffer(offset: usize, size: usize) -> String { - BUFFER.with(|chunk| { - let mut chunk = chunk.borrow_mut(); - - let chunk = chunk.as_mut().unwrap(); - - std::str::from_utf8(&chunk[offset..offset + size]) - .unwrap() - .to_string() - }) - } - - pub fn store_buffer(filename: String) -> usize { - let res = BUFFER.with(|chunk| { - let chunk = chunk.borrow_mut(); - - let chunk = chunk.as_ref().unwrap(); - - FS.with(|fs| { - let mut fs = fs.borrow_mut(); - - let root_fd = (*fs).root_fd(); - - let fd = (*fs) - .open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) - .unwrap(); - - let write_content = [SrcBuf { - buf: chunk.as_ptr(), - len: chunk.len(), - }]; - - let res = (*fs).write_vec(fd, write_content.as_ref()).unwrap(); - - (*fs).close(fd).unwrap(); - - res as usize - }) - }); - - res - } - - pub fn store_buffer_in_1000b_segments(filename: String) -> (u64, usize) { - let stime = instruction_counter(); - - let res = BUFFER.with(|chunk| { - let chunk = chunk.borrow_mut(); - - let chunk = chunk.as_ref().unwrap(); - - FS.with(|fs| { - let mut fs = fs.borrow_mut(); - - let root_fd = (*fs).root_fd(); - - let fd = (*fs) - .open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) - .unwrap(); - - (*fs).seek(fd, 0, Whence::SET).unwrap(); - - let len = chunk.len(); - - let mut p = 0; - let part_len = SEGMENT_SIZE; - let mut res = 0; - - while p < len { - let write_len = (len - p).min(part_len); - - let write_content = [SrcBuf { - buf: chunk[p..(p + part_len).min(len)].as_ptr(), - len: write_len, - }]; - - res += (*fs).write_vec(fd, write_content.as_ref()).unwrap(); - - p += write_len; - } - - (*fs).close(fd).unwrap(); - - res as usize - }) - }); - - let etime = instruction_counter(); - - (etime - stime, res) - } - pub fn store_buffer_in_1000b_segments_10_files(filename: String) -> (u64, usize) { let stime = instruction_counter(); @@ -431,7 +317,7 @@ mod test_env { for i in 0..FILES_COUNT { let fd = (*fs) - .open_or_create( + .open( root_fd, &format!("{}{}", filename, i), FdStat::default(), @@ -480,94 +366,6 @@ mod test_env { (etime - stime, res) } - pub fn load_buffer(filename: String) -> (u64, usize) { - let stime = instruction_counter(); - - let res = BUFFER.with(|chunk| { - let mut chunk = chunk.borrow_mut(); - - let chunk = chunk.as_mut().unwrap(); - - FS.with(|fs| { - let mut fs = fs.borrow_mut(); - - let root_fd = (*fs).root_fd(); - - let fd = (*fs) - .open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) - .unwrap(); - - let size = (*fs).metadata(fd).unwrap().size as usize; - - (*fs).seek(fd, 0, Whence::SET).unwrap(); - - let read_content = [DstBuf { - buf: chunk.as_mut_ptr(), - len: size, - }]; - - unsafe { chunk.set_len(size) }; - - let res = (*fs).read_vec(fd, &read_content).unwrap(); - - res as usize - }) - }); - - let etime = instruction_counter(); - - (etime - stime, res) - } - - pub fn load_buffer_in_1000b_segments(filename: String) -> (u64, usize) { - let stime = instruction_counter(); - - let res = BUFFER.with(|chunk| { - let mut chunk = chunk.borrow_mut(); - - let chunk = chunk.as_mut().unwrap(); - - FS.with(|fs| { - let mut fs = fs.borrow_mut(); - - let root_fd = (*fs).root_fd(); - - let fd = (*fs) - .open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) - .unwrap(); - - let len = (*fs).metadata(fd).unwrap().size as usize; - - (*fs).seek(fd, 0, Whence::SET).unwrap(); - - let mut p = 0; - let part_len = SEGMENT_SIZE; - let mut res = 0; - - unsafe { chunk.set_len(len) }; - - while p < len { - let read_len = (len - p).min(part_len); - - let read_content = [DstBuf { - buf: chunk[p..p + read_len].as_mut_ptr(), - len: read_len, - }]; - - res += (*fs).read_vec(fd, read_content.as_ref()).unwrap(); - - p += read_len; - } - - res as usize - }) - }); - - let etime = instruction_counter(); - - (etime - stime, res) - } - pub fn load_buffer_in_1000b_segments_10_files(filename: String) -> (u64, usize) { let stime = instruction_counter(); @@ -585,7 +383,7 @@ mod test_env { for i in 0..FILES_COUNT { let fd = (*fs) - .open_or_create( + .open( root_fd, &format!("{}{}", filename, i), FdStat::default(), @@ -636,140 +434,318 @@ mod test_env { (etime - stime, res) } - fn write_100mb(file_name: &str) { - check_buffer("abc1234567".to_string(), 0); - + fn read_100mb_in_segments_10_files(file_name: &str) { append_buffer("abc1234567".to_string(), 10_000_000); - check_buffer("abc1234567".to_string(), 10_000_000); + // store_buffer("temp1.txt".to_string()); + store_buffer_in_1000b_segments_10_files(file_name.to_string()); + // store_buffer("temp2.txt".to_string()); - store_buffer("temp2.txt".to_string()); + clear_buffer(); // bench - store_buffer(file_name.to_string()); + load_buffer_in_1000b_segments_10_files(file_name.to_string()); + + check_buffer("abc1234567".to_string(), 10_000_000); } - fn write_100mb_over_existing(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); + #[test] + fn file_read_100mb_in_segments_10_files() { + read_100mb_in_segments_10_files("file.txt") + } - store_buffer(file_name.to_string()); - store_buffer("temp2.txt".to_string()); + // deterministic 32-bit pseudo-random number provider + fn next_rand(cur_rand: u64) -> u64 { + let a: u64 = 1103515245; + let c: u64 = 12345; + let m: u64 = 1 << 31; - // bench - store_buffer(file_name.to_string()); + (a.wrapping_mul(cur_rand).wrapping_add(c)) % m } - fn read_100mb(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); - store_buffer(file_name.to_string()); - store_buffer("temp2.txt".to_string()); + pub fn generate_random_file_structure( + op_count: u32, // number of operations to do + cur_rand: u64, // current random seed + depth: u32, // current folder depth + parent_fd: Fd, // host fd + fs: &mut FileSystem, + ) -> Result { + let mut op_count = op_count; + let mut cur_rand = cur_rand; - check_buffer("abc1234567".to_string(), 10_000_000); - clear_buffer(); - check_buffer("abc1234567".to_string(), 0); + while op_count > 0 { + op_count -= 1; - // bench - load_buffer(file_name.to_string()); + cur_rand = next_rand(cur_rand); + let action = cur_rand % 10; // e.g., 0..9 - check_buffer("abc1234567".to_string(), 10_000_000); - } + match action { + 0 => { + // create a file using open + let filename = format!("file{}.txt", op_count); - fn write_100mb_in_segments(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); + let fd = fs.open( + parent_fd, + &filename, + FdStat::default(), + OpenFlags::CREATE, + op_count as u64, + )?; - store_buffer("temp1.txt".to_string()); + fs.seek(fd, op_count as i64 * 100, Whence::SET)?; - //bench - store_buffer_in_1000b_segments(file_name.to_string()); + fs.write(fd, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?; - assert_eq!(file_size(file_name.to_string()), 100_000_000); - clear_buffer(); - load_buffer(file_name.to_string()); - check_buffer("abc1234567".to_string(), 10_000_000); - } + fs.close(fd)?; + } + 1 => { + // create a file using create_open_file + let filename = format!("file{}.txt", op_count); + + let fd = fs.create_open_file( + parent_fd, + &filename, + FdStat::default(), + op_count as u64, + ); + + if fd.is_err() { + continue; + } + + let fd = fd?; + + let write_content1 = "12345"; + let write_content2 = "67890"; + + let src = [ + SrcBuf { + buf: write_content1.as_ptr(), + len: write_content1.len(), + }, + SrcBuf { + buf: write_content2.as_ptr(), + len: write_content2.len(), + }, + ]; + + fs.write_vec_with_offset(fd, src.as_ref(), op_count as FileSize * 1000)?; + + fs.close(fd)?; + } - fn write_100mb_in_segments_over_existing(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); + 2 => { + // create a directory using mkdir. + let dirname = format!("dir{}", op_count); - store_buffer("temp1.txt".to_string()); - store_buffer(file_name.to_string()); - store_buffer("temp2.txt".to_string()); + // function might fail because of the naming conflict + let _ = fs.mkdir(parent_fd, &dirname, FdStat::default(), op_count as u64); + } + 3 => { + // create a directory using create_open_directory. + let dirname = format!("dir{}", op_count); + + let fd = fs.create_open_directory( + parent_fd, + &dirname, + FdStat::default(), + op_count as u64, + )?; + fs.close(fd)?; + } + 4 => { + // create or open a directory using open + let dirname = format!("dir_o{}", op_count); + + let fd = fs.open( + parent_fd, + &dirname, + FdStat::default(), + OpenFlags::DIRECTORY | OpenFlags::CREATE, + op_count as u64, + )?; + + fs.close(fd)?; + } - // bench - store_buffer_in_1000b_segments(file_name.to_string()); - } + 5 => { + // remove a random folder item + let files = fs.list_dir_internal(parent_fd, None)?; + + if !files.is_empty() { + let cur_rand = next_rand(cur_rand); + let (node, name) = &files[cur_rand as usize % files.len()]; + + let meta = fs.metadata_from_node(*node)?; + + match meta.file_type { + FileType::Directory => { + let _ = fs.remove_dir(parent_fd, name); + } + FileType::RegularFile => { + let _ = fs.remove_file(parent_fd, name); + } + FileType::SymbolicLink => panic!("Symlink are not supported!"), + } + } + } - fn read_100mb_in_segments(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); + 6 => { + // enter subfolder + let dirs = fs.list_dir_internal(parent_fd, Some(FileType::Directory))?; - store_buffer("temp1.txt".to_string()); - store_buffer(file_name.to_string()); - store_buffer("temp2.txt".to_string()); + if !dirs.is_empty() { + let cur_rand = next_rand(cur_rand); + let (_node, name) = &dirs[cur_rand as usize % dirs.len()]; - clear_buffer(); - check_buffer("abc1234567".to_string(), 0); + let dir_fd = fs.open( + parent_fd, + name, + FdStat::default(), + OpenFlags::empty(), + op_count as u64, + )?; + + let res = generate_random_file_structure( + op_count, + cur_rand, + depth + 1, + dir_fd, + fs, + ); + + fs.close(dir_fd)?; + + op_count = res?; + } + } - //bench - load_buffer_in_1000b_segments(file_name.to_string()); + 7 => { + // exit the current folder + if depth > 0 { + return Ok(op_count); + } + } - check_buffer("abc1234567".to_string(), 10_000_000); - } + 8 => { + let dirs = fs.list_dir_internal(parent_fd, Some(FileType::Directory))?; - fn write_100mb_in_segments_10_files(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); - //store_buffer("temp1.txt".to_string()); + // Random open/close a file (or directory) + if !dirs.is_empty() { + let cur_rand = next_rand(cur_rand); + let (_node, filename) = &dirs[cur_rand as usize % dirs.len()]; - // bench - store_buffer_in_1000b_segments_10_files(file_name.to_string()); + let fd = fs.open( + parent_fd, + filename, + FdStat::default(), + OpenFlags::empty(), + op_count as u64, + )?; - clear_buffer(); - load_buffer_in_1000b_segments_10_files(file_name.to_string()); - check_buffer("abc1234567".to_string(), 10_000_000); - } + fs.close(fd)?; + } + } - fn write_100mb_in_segments_over_existing_10_files(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); + 9 => { + // occasionly increate counter to cause naming conflicts and provoce errors + op_count += 2; + } - //store_buffer("temp1.txt".to_string()); - store_buffer_in_1000b_segments_10_files(file_name.to_string()); - store_buffer("temp2.txt".to_string()); + _ => { + panic!("Incorrect action {action}"); + } + } + } - // bench - store_buffer_in_1000b_segments_10_files(file_name.to_string()); + Ok(op_count) } - fn read_20mb_in_segments_10_files(file_name: &str) { - append_buffer("abc1234567".to_string(), 2_000_000); + fn list_all_files_as_string(fs: &mut FileSystem) -> Result { + let mut paths = Vec::new(); - // store_buffer("temp1.txt".to_string()); - store_buffer_in_1000b_segments_10_files(file_name.to_string()); - // store_buffer("temp2.txt".to_string()); + scan_directory(fs, fs.root_fd(), "", &mut paths)?; + Ok(paths.join("\n")) + } - clear_buffer(); + fn scan_directory( + fs: &mut FileSystem, + dir_fd: u32, + current_path: &str, + collected_paths: &mut Vec, + ) -> Result<(), crate::error::Error> { + let meta = fs.metadata(dir_fd)?; + + // add current folder as well + let entry_path = if current_path.is_empty() { + format!("/. {}", meta.size) + } else { + format!("{}/. {}", current_path, meta.size) + }; + collected_paths.push(entry_path); - // bench - load_buffer_in_1000b_segments_10_files(file_name.to_string()); + let entries = fs.list_dir_internal(dir_fd, None)?; - check_buffer("abc1234567".to_string(), 2_000_000); - } + for (entry_node, filename) in entries { + let meta = fs.metadata_from_node(entry_node)?; - fn read_100mb_in_segments_10_files(file_name: &str) { - append_buffer("abc1234567".to_string(), 10_000_000); + let entry_path = if current_path.is_empty() { + format!("/{} {}", filename, meta.size) + } else { + format!("{}/{} {}", current_path, filename, meta.size) + }; - // store_buffer("temp1.txt".to_string()); - store_buffer_in_1000b_segments_10_files(file_name.to_string()); - // store_buffer("temp2.txt".to_string()); + match meta.file_type { + FileType::Directory => { + let child_fd = fs.open( + dir_fd, + &filename, + FdStat::default(), + OpenFlags::DIRECTORY, + 0, + )?; - clear_buffer(); + scan_directory(fs, child_fd, &entry_path, collected_paths)?; - // bench - load_buffer_in_1000b_segments_10_files(file_name.to_string()); + fs.close(child_fd)?; + } + FileType::RegularFile => { + collected_paths.push(entry_path); + } + FileType::SymbolicLink => todo!(), + } + } - check_buffer("abc1234567".to_string(), 10_000_000); + Ok(()) } #[test] - fn file_read_100mb_in_segments_10_files() { - read_100mb_in_segments_10_files("file.txt") + fn test_generator() { + let memory = DefaultMemoryImpl::default(); + + let storage = StableStorage::new(memory); + let mut fs = FileSystem::new(Box::new(storage)).unwrap(); + + let root_fd = fs + .create_open_directory(fs.root_fd(), "root_dir", FdStat::default(), 0) + .unwrap(); + + // generate random file structure. + generate_random_file_structure(1700, 35, 0, root_fd, &mut fs).unwrap(); + fs.close(root_fd).unwrap(); + + // test deletion + + // get all files + let files = list_all_files_as_string(&mut fs).unwrap(); + + println!("------------------------------------------"); + println!("FILE STRUCTURE"); + println!("{}", files); + + // try to delete the generated folder + //fs.remove_recursive(fs.root_fd(), "root_dir").unwrap(); + //fs.remove_file(fs.root_fd(), "root_dir/file4.txt").unwrap(); + //fs.remove_dir(fs.root_fd(), "root_dir").unwrap(); } } diff --git a/tests/canister_initial/.gitignore b/tests/canister_initial/.gitignore index 49c89a1..dab4491 100644 --- a/tests/canister_initial/.gitignore +++ b/tests/canister_initial/.gitignore @@ -23,3 +23,5 @@ dist/ # environment variables .env + +.codegpt \ No newline at end of file diff --git a/tests/canister_initial/Cargo.lock b/tests/canister_initial/Cargo.lock index 80b9c9e..e7bcefc 100644 --- a/tests/canister_initial/Cargo.lock +++ b/tests/canister_initial/Cargo.lock @@ -1,12 +1,12 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 +version = 4 [[package]] name = "anyhow" -version = "1.0.86" +version = "1.0.95" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da" +checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04" [[package]] name = "arrayvec" @@ -16,9 +16,9 @@ checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b" [[package]] name = "autocfg" -version = "1.3.0" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" [[package]] name = "binread" @@ -66,9 +66,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "candid" -version = "0.10.9" +version = "0.10.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7df77a80c72fcd356cf37ff59c812f37ff06dc9a81232b3aff0a308cb5996904" +checksum = "d04aa85a9ba2542bded33d1eff0ffb17cb98b1be8117e0a25e1ad8c62bedc881" dependencies = [ "anyhow", "binread", @@ -96,7 +96,7 @@ dependencies = [ "lazy_static", "proc-macro2", "quote", - "syn 2.0.91", + "syn 2.0.92", ] [[package]] @@ -104,17 +104,24 @@ name = "canister_initial_backend" version = "0.1.0" dependencies = [ "candid", - "ic-cdk 0.15.0", + "ciborium", + "hex", + "ic-cdk", "ic-cdk-timers", "ic-stable-structures", + "serde", + "serde_bytes", "stable-fs", ] [[package]] name = "cc" -version = "1.1.6" +version = "1.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f" +checksum = "8d6dbb628b8f8555f86d0323c2eb39e3ec81901f4b83e091db8a6a76d316a333" +dependencies = [ + "shlex", +] [[package]] name = "cfg-if" @@ -151,9 +158,9 @@ dependencies = [ [[package]] name = "cpufeatures" -version = "0.2.12" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" +checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3" dependencies = [ "libc", ] @@ -207,9 +214,9 @@ checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" [[package]] name = "futures" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" dependencies = [ "futures-channel", "futures-core", @@ -222,9 +229,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" dependencies = [ "futures-core", "futures-sink", @@ -232,15 +239,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" [[package]] name = "futures-executor" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" dependencies = [ "futures-core", "futures-task", @@ -249,38 +256,38 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" [[package]] name = "futures-macro" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" dependencies = [ "proc-macro2", "quote", - "syn 2.0.91", + "syn 2.0.92", ] [[package]] name = "futures-sink" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" [[package]] name = "futures-task" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" [[package]] name = "futures-util" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" dependencies = [ "futures-channel", "futures-core", @@ -320,32 +327,6 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" -[[package]] -name = "ic-cdk" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8859bc2b863a77750acf199e1fb7e3fc403e1b475855ba13f59cb4e4036d238" -dependencies = [ - "candid", - "ic-cdk-macros 0.13.2", - "ic0 0.21.1", - "serde", - "serde_bytes", -] - -[[package]] -name = "ic-cdk" -version = "0.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c44983d6e97135d86132111bae5b86c34c498d96b4f182638bebcc7ac07e03c" -dependencies = [ - "candid", - "ic-cdk-macros 0.15.0", - "ic0 0.23.0", - "serde", - "serde_bytes", -] - [[package]] name = "ic-cdk" version = "0.17.1" @@ -353,40 +334,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "122efbcb0af5280d408a75a57b7dc6e9d92893bf6ed9cc98fe4dcff51f18b67c" dependencies = [ "candid", - "ic-cdk-macros 0.17.1", - "ic0 0.23.0", + "ic-cdk-macros", + "ic0", "serde", "serde_bytes", ] -[[package]] -name = "ic-cdk-macros" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a45800053d80a6df839a71aaea5797e723188c0b992618208ca3b941350c7355" -dependencies = [ - "candid", - "proc-macro2", - "quote", - "serde", - "serde_tokenstream 0.1.7", - "syn 1.0.109", -] - -[[package]] -name = "ic-cdk-macros" -version = "0.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3af44fb4ec3a4b18831c9d3303ca8fa2ace846c4022d50cb8df4122635d3782e" -dependencies = [ - "candid", - "proc-macro2", - "quote", - "serde", - "serde_tokenstream 0.2.1", - "syn 2.0.91", -] - [[package]] name = "ic-cdk-macros" version = "0.17.1" @@ -397,19 +350,19 @@ dependencies = [ "proc-macro2", "quote", "serde", - "serde_tokenstream 0.2.1", - "syn 2.0.91", + "serde_tokenstream", + "syn 2.0.92", ] [[package]] name = "ic-cdk-timers" -version = "0.7.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "054727a3a1c486528b96349817d54290ff70df6addf417def456ea708a16f7fb" +checksum = "fb8fd812a9e26f6aa00594546f8fbf4d4853f39c3ba794c8ff11ecf86fd3c9e4" dependencies = [ "futures", - "ic-cdk 0.13.2", - "ic0 0.21.1", + "ic-cdk", + "ic0", "serde", "serde_bytes", "slotmap", @@ -424,12 +377,6 @@ dependencies = [ "ic_principal", ] -[[package]] -name = "ic0" -version = "0.21.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a54b5297861c651551676e8c43df805dad175cc33bc97dbd992edbbb85dcbcdf" - [[package]] name = "ic0" version = "0.23.0" @@ -463,9 +410,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" [[package]] name = "libc" -version = "0.2.155" +version = "0.2.169" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a" [[package]] name = "memchr" @@ -510,9 +457,9 @@ checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" [[package]] name = "pin-project-lite" -version = "0.2.14" +version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" +checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff" [[package]] name = "pin-utils" @@ -542,33 +489,33 @@ dependencies = [ [[package]] name = "psm" -version = "0.1.21" +version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874" +checksum = "200b9ff220857e53e184257720a14553b2f4aa02577d2ed9842d45d4b9654810" dependencies = [ "cc", ] [[package]] name = "quote" -version = "1.0.36" +version = "1.0.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" dependencies = [ "proc-macro2", ] [[package]] name = "rustversion" -version = "1.0.17" +version = "1.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6" +checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4" [[package]] name = "serde" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e" +checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70" dependencies = [ "serde_derive", ] @@ -584,36 +531,25 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e" +checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.91", -] - -[[package]] -name = "serde_tokenstream" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "797ba1d80299b264f3aac68ab5d12e5825a561749db4df7cd7c8083900c5d4e9" -dependencies = [ - "proc-macro2", - "serde", - "syn 1.0.109", + "syn 2.0.92", ] [[package]] name = "serde_tokenstream" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8790a7c3fe883e443eaa2af6f705952bc5d6e8671a220b9335c8cae92c037e74" +checksum = "64060d864397305347a78851c51588fd283767e7e7589829e8121d65512340f1" dependencies = [ "proc-macro2", "quote", "serde", - "syn 2.0.91", + "syn 2.0.92", ] [[package]] @@ -627,6 +563,12 @@ dependencies = [ "digest", ] +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + [[package]] name = "slab" version = "0.4.9" @@ -647,11 +589,11 @@ dependencies = [ [[package]] name = "stable-fs" -version = "0.6.5" +version = "0.7.0" dependencies = [ "bitflags", "ciborium", - "ic-cdk 0.17.1", + "ic-cdk", "ic-stable-structures", "serde", "serde_bytes", @@ -659,15 +601,15 @@ dependencies = [ [[package]] name = "stacker" -version = "0.1.15" +version = "0.1.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c886bd4480155fd3ef527d45e9ac8dd7118a898a46530b7b94c3e21866259fce" +checksum = "799c883d55abdb5e98af1a7b3f23b9b6de8ecada0ecac058672d7635eb48ca7b" dependencies = [ "cc", "cfg-if", "libc", "psm", - "winapi", + "windows-sys", ] [[package]] @@ -683,9 +625,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.91" +version = "2.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d53cbcb5a243bd33b7858b1d7f4aca2153490815872d86d955d6ea29f743c035" +checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126" dependencies = [ "proc-macro2", "quote", @@ -694,22 +636,22 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.63" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.63" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.91", + "syn 2.0.92", ] [[package]] @@ -726,15 +668,15 @@ checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" [[package]] name = "unicode-ident" -version = "1.0.12" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" +checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" [[package]] name = "unicode-width" -version = "0.1.13" +version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d" +checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" [[package]] name = "version_check" @@ -743,23 +685,74 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] -name = "winapi" -version = "0.3.9" +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", ] [[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" +name = "windows_x86_64_msvc" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" diff --git a/tests/canister_initial/src/canister_initial_backend/Cargo.toml b/tests/canister_initial/src/canister_initial_backend/Cargo.toml index e389ff8..434737c 100644 --- a/tests/canister_initial/src/canister_initial_backend/Cargo.toml +++ b/tests/canister_initial/src/canister_initial_backend/Cargo.toml @@ -10,7 +10,12 @@ crate-type = ["cdylib"] [dependencies] candid = "0.10" -ic-cdk = "0.15" -ic-cdk-timers = "0.7" # Feel free to remove this dependency if you don't need timers -ic-stable-structures = "0.6.5" +ic-cdk = "0.17" +ic-cdk-timers = "0.11" # Feel free to remove this dependency if you don't need timers +ic-stable-structures = "0.6.7" stable-fs = {path="../../../../../stable-fs"} + +serde = "1.0.216" +serde_bytes = "0.11.15" +ciborium = "0.2.2" +hex = "0.4" diff --git a/tests/canister_initial/src/canister_initial_backend/src/lib.rs b/tests/canister_initial/src/canister_initial_backend/src/lib.rs index 8d84d76..0b44fb1 100644 --- a/tests/canister_initial/src/canister_initial_backend/src/lib.rs +++ b/tests/canister_initial/src/canister_initial_backend/src/lib.rs @@ -1,15 +1,36 @@ use std::{cell::RefCell, str::FromStr}; -use stable_fs::{fs::{DstBuf, FdStat, FileSystem, OpenFlags, SrcBuf, Whence}, storage::stable::StableStorage}; -use ic_stable_structures::{memory_manager::{MemoryId, MemoryManager}, DefaultMemoryImpl, Memory}; - +use ic_stable_structures::{ + memory_manager::{MemoryId, MemoryManager}, + DefaultMemoryImpl, Memory, +}; + +use hex; +use ic_cdk::api::stable::WASM_PAGE_SIZE_IN_BYTES; +use ic_stable_structures::VectorMemory; +use serde::Deserialize; +use serde::Serialize; +use stable_fs::fs::ChunkType; +use stable_fs::storage::types::DirEntryIndex; +use stable_fs::storage::types::FileSize; +use stable_fs::storage::types::FileType; +use stable_fs::storage::types::Metadata; +use stable_fs::storage::types::Node; +use stable_fs::storage::types::Times; +use std::mem; +use std::mem::MaybeUninit; +use std::ptr; + +use stable_fs::{ + fs::{DstBuf, FdStat, FileSystem, OpenFlags, SrcBuf, Whence}, + storage::stable::StableStorage, +}; #[ic_cdk::query] fn greet(name: String) -> String { format!("Hello, {}!", name) } - #[ic_cdk::query] fn greet_times(name: String, times: usize) -> Vec { let mut res = Vec::new(); @@ -21,7 +42,6 @@ fn greet_times(name: String, times: usize) -> Vec { res } - const PROFILING: MemoryId = MemoryId::new(100); thread_local! { @@ -34,7 +54,7 @@ thread_local! { let memory_manager = m.borrow(); let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210u8); - + let fs = RefCell::new( FileSystem::new(Box::new(storage)).unwrap() ); @@ -52,7 +72,6 @@ thread_local! { #[ic_cdk::update] pub fn append_buffer(text: String, times: usize) -> usize { - BUFFER.with(|buffer| { let mut buffer = buffer.borrow_mut(); @@ -72,7 +91,6 @@ pub fn append_buffer(text: String, times: usize) -> usize { #[ic_cdk::update] pub fn clear_buffer() { - BUFFER.with(|chunk| { let mut chunk = chunk.borrow_mut(); @@ -93,19 +111,19 @@ pub fn clear_buffer() { #[ic_cdk::update] pub fn read_buffer(offset: usize, size: usize) -> String { - BUFFER.with(|chunk| { let mut chunk = chunk.borrow_mut(); let chunk = chunk.as_mut().unwrap(); - std::str::from_utf8(&chunk[offset..offset+size]).unwrap().to_string() + std::str::from_utf8(&chunk[offset..offset + size]) + .unwrap() + .to_string() }) } #[ic_cdk::update] pub fn chunk_size() -> usize { - BUFFER.with(|chunk| { let mut chunk = chunk.borrow_mut(); @@ -117,12 +135,11 @@ pub fn chunk_size() -> usize { #[ic_cdk::update] pub fn store_buffer(filename: String) -> (u64, usize) { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); let res = BUFFER.with(|chunk| { - let chunk = chunk.borrow_mut(); - + let chunk = chunk.as_ref().unwrap(); FS.with(|fs| { @@ -130,14 +147,14 @@ pub fn store_buffer(filename: String) -> (u64, usize) { let root_fd = (*fs).root_fd(); - let fd = (*fs).open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42).unwrap(); + let fd = (*fs) + .open(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) + .unwrap(); - let write_content = [ - SrcBuf { - buf: chunk.as_ptr(), - len: chunk.len(), - }, - ]; + let write_content = [SrcBuf { + buf: chunk.as_ptr(), + len: chunk.len(), + }]; let res = (*fs).write_vec(fd, write_content.as_ref()).unwrap(); @@ -145,19 +162,18 @@ pub fn store_buffer(filename: String) -> (u64, usize) { }) }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); (etime - stime, res) } #[ic_cdk::update] pub fn load_buffer(filename: String) -> (u64, usize) { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); let res = BUFFER.with(|chunk| { - let mut chunk = chunk.borrow_mut(); - + let chunk = chunk.as_mut().unwrap(); FS.with(|fs| { @@ -165,20 +181,20 @@ pub fn load_buffer(filename: String) -> (u64, usize) { let root_fd = (*fs).root_fd(); - let fd = (*fs).open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42).unwrap(); + let fd = (*fs) + .open(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) + .unwrap(); let size = (*fs).seek(fd, 0, Whence::END).unwrap() as usize; (*fs).seek(fd, 0, Whence::SET).unwrap(); - let read_content = [ - DstBuf { - buf: chunk.as_mut_ptr(), - len: size, - }, - ]; + let read_content = [DstBuf { + buf: chunk.as_mut_ptr(), + len: size, + }]; - unsafe {chunk.set_len(size)}; + unsafe { chunk.set_len(size) }; let res = (*fs).read_vec(fd, &read_content).unwrap(); @@ -186,12 +202,11 @@ pub fn load_buffer(filename: String) -> (u64, usize) { }) }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); (etime - stime, res) } - pub fn profiling_init() { let memory = MEMORY_MANAGER.with(|m| m.borrow().get(PROFILING)); memory.grow(4096); @@ -208,10 +223,9 @@ fn init() { #[ic_cdk::update] fn write_kib_text(filename: String, kb_size: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -219,17 +233,21 @@ fn write_kib_text(filename: String, kb_size: usize) -> u64 { // 64 byte block let text = "0123456789012345678901234567890123456789012345678901234567890123"; - let write_content = [ - SrcBuf { - buf: text.as_ptr(), - len: text.len(), - }, - ]; - + let write_content = [SrcBuf { + buf: text.as_ptr(), + len: text.len(), + }]; + let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); let times = 1024 * kb_size / text.len(); @@ -237,45 +255,47 @@ fn write_kib_text(filename: String, kb_size: usize) -> u64 { for _ in 0..times { fs.write_vec(fd, write_content.as_ref()).unwrap(); } - - let _ = fs.close(fd); + let _ = fs.close(fd); }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } - #[ic_cdk::update] fn write_mib_text(filename: String, mib_size: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); // create 4kib block - let mut text1kib = "0123456789012345678901234567890123456789012345678901234567890123".to_string(); + let mut text1kib = + "0123456789012345678901234567890123456789012345678901234567890123".to_string(); while text1kib.len() < 4096 { text1kib.push_str(&text1kib.clone()); } - let write_content = [ - SrcBuf { - buf: text1kib.as_ptr(), - len: text1kib.len(), - }, - ]; - + let write_content = [SrcBuf { + buf: text1kib.as_ptr(), + len: text1kib.len(), + }]; + let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); let times = 1024 * 1024 * mib_size / text1kib.len(); @@ -283,58 +303,58 @@ fn write_mib_text(filename: String, mib_size: usize) -> u64 { for _ in 0..times { fs.write_vec(fd, write_content.as_ref()).unwrap(); } - - let _ = fs.close(fd); + let _ = fs.close(fd); }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } #[ic_cdk::update] fn read_bytes(filename: String, offset: i64, size: usize) -> (u64, usize) { - - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); let mut res = Vec::with_capacity(size); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::empty(), 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); + + let read_content = [DstBuf { + buf: res.as_mut_ptr(), + len: size, + }]; + + let len = fs + .read_vec_with_offset(fd, &read_content, offset as u64) .unwrap(); - let read_content = [ - DstBuf { - buf: res.as_mut_ptr(), - len: size, - }, - ]; - - let len = fs.read_vec_with_offset(fd, &read_content, offset as u64).unwrap(); - let _ = fs.close(fd); - unsafe {res.set_len(len as usize)}; - + unsafe { res.set_len(len as usize) }; }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); (etime - stime, res.len()) } - // delete file #[ic_cdk::query] fn delete_file(filename: String) { FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -346,7 +366,6 @@ fn delete_file(filename: String) { #[ic_cdk::query] fn delete_folder(filename: String) { FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -354,52 +373,59 @@ fn delete_folder(filename: String) { }); } - #[ic_cdk::query] fn list_files(path: String) -> Vec { let mut res = vec![]; FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); - let fd = fs.open_or_create(dir, path.as_str(), FdStat::default(), OpenFlags::DIRECTORY, 0).unwrap(); + let fd = fs + .open( + dir, + path.as_str(), + FdStat::default(), + OpenFlags::DIRECTORY, + 0, + ) + .unwrap(); let meta = fs.metadata(fd).unwrap(); let mut entry_index = meta.first_dir_entry; while let Some(index) = entry_index { - let entry = fs.get_direntry(fd, index).unwrap(); - let filename_str = std::str::from_utf8(&entry.name.bytes[0..(entry.name.length as usize)]).unwrap(); + let filename_str = + std::str::from_utf8(&entry.name.bytes[0..(entry.name.length as usize)]).unwrap(); let st = String::from_str(filename_str).unwrap(); res.push(st); entry_index = entry.next_entry; - } - }); res } - #[ic_cdk::query] fn cat_file(filename: String) -> String { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); let fd = fs - .open_or_create(dir, filename.as_str() , FdStat::default(), OpenFlags::empty(), 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) .unwrap(); let mut buf = [0u8; 100]; @@ -416,77 +442,75 @@ fn cat_file(filename: String) -> String { #[ic_cdk::update] fn create_depth_folders(path: String, count: usize) -> String { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); let root_dir = fs.root_fd(); let mut dir_name = "d0".to_string(); - + for num in 1..count { dir_name = format!("{}/d{}", dir_name, num); } - fs.create_dir(root_dir, dir_name.as_str(), FdStat::default(), 0).unwrap(); + fs.mkdir(root_dir, dir_name.as_str(), FdStat::default(), 0) + .unwrap(); format!("{}/{}", path, dir_name) - }) } #[ic_cdk::update] fn create_files(path: String, count: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); for num in 0..count { - let filename = format!("{}/{}.txt", path, num); let fd = fs - .open_or_create(dir, filename.as_str() , FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); // 64 byte block - let text = format!("0123456789012345678901234567890123456789012345678901234567890123:{}", filename); - - let write_content = [ - SrcBuf { - buf: text.as_ptr(), - len: text.len(), - }, - ]; - + let text = format!( + "0123456789012345678901234567890123456789012345678901234567890123:{}", + filename + ); + + let write_content = [SrcBuf { + buf: text.as_ptr(), + len: text.len(), + }]; + fs.write_vec(fd, write_content.as_ref()).unwrap(); - - let _ = fs.close(fd); + let _ = fs.close(fd); } - }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } - #[ic_cdk::update] fn append_text(filename: String, text: String, times: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -497,71 +521,85 @@ fn append_text(filename: String, text: String, times: usize) -> u64 { txt.push_str(&text); } - let write_content = [ - SrcBuf { - buf: txt.as_ptr(), - len: txt.len(), - }, - ]; - + let write_content = [SrcBuf { + buf: txt.as_ptr(), + len: txt.len(), + }]; + let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); fs.write_vec(fd, write_content.as_ref()).unwrap(); - - let _ = fs.close(fd); + let _ = fs.close(fd); }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } - #[ic_cdk::query] fn read_text(filename: String, offset: i64, size: usize) -> String { - FS.with(|fs| { let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); - let fd = fs.open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::empty(), 0).unwrap(); + let fd = fs + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); let mut content = (0..size).map(|_| ".").collect::(); - let read_content = [ - DstBuf { - buf: content.as_mut_ptr(), - len: content.len(), - }, - ]; - - let read = fs.read_vec_with_offset(fd, &read_content, offset as u64).unwrap(); + let read_content = [DstBuf { + buf: content.as_mut_ptr(), + len: content.len(), + }]; + + let read = fs + .read_vec_with_offset(fd, &read_content, offset as u64) + .unwrap(); let min = std::cmp::min(read, size as u64) as usize; - + let _ = fs.close(fd); content[..min].to_string() }) - } #[ic_cdk::query] fn file_size(filename: String) -> usize { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); - let fd = fs.open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::empty(), 0).unwrap(); + let fd = fs + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); let meta = fs.metadata(fd).unwrap(); @@ -569,4 +607,203 @@ fn file_size(filename: String) -> usize { size as usize }) -} \ No newline at end of file +} + +pub fn new_vector_memory() -> VectorMemory { + use std::{cell::RefCell, rc::Rc}; + + Rc::new(RefCell::new(Vec::new())) +} + +#[inline] +pub fn grow_memory(memory: &dyn Memory, max_address: FileSize) { + let pages_required = max_address.div_ceil(WASM_PAGE_SIZE_IN_BYTES); + + let cur_pages = memory.size(); + + if cur_pages < pages_required { + memory.grow(pages_required - cur_pages); + } +} + +#[inline] +pub fn read_obj(memory: &dyn Memory, address: u64, obj: &mut T) { + let obj_size = std::mem::size_of::(); + + let obj_bytes = unsafe { std::slice::from_raw_parts_mut(obj as *mut T as *mut u8, obj_size) }; + + memory.read(address, obj_bytes); +} + +#[inline] +pub fn write_obj(memory: &dyn Memory, address: u64, obj: &T) { + let obj_size = std::mem::size_of::(); + + let obj_bytes = unsafe { std::slice::from_raw_parts(obj as *const T as *const u8, obj_size) }; + + grow_memory(memory, address + obj_size as u64); + + memory.write(address, obj_bytes); +} + +#[inline] +pub fn to_binary(obj: &T) -> Vec { + let obj_size = std::mem::size_of::(); + + let obj_bytes = unsafe { std::slice::from_raw_parts(obj as *const T as *const u8, obj_size) }; + + let ret: Vec = obj_bytes.to_vec(); + + ret +} + +#[ic_cdk::query] +fn check_metadata_format() { + #[repr(C)] + #[derive(Clone, Debug, Default, PartialEq)] + pub struct MetadataC { + pub first_dir_entry: Option, + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + let mem = new_vector_memory(); + + let meta_old = Metadata { + node: 23, + file_type: FileType::RegularFile, + link_count: 3, + size: 123, + times: Times::default(), + first_dir_entry: Some(24), + last_dir_entry: Some(35), + chunk_type: Some(stable_fs::fs::ChunkType::V2), + maximum_size_allowed: None, + }; + + write_obj(&mem, 16, &meta_old); + + let mut meta_new = MetadataC::default(); + + read_obj(&mem, 16, &mut meta_new); + + assert_eq!(meta_old.node, meta_new.node); + assert_eq!(meta_old.file_type, meta_new.file_type); + assert_eq!(meta_old.link_count, meta_new.link_count); + assert_eq!(meta_old.size, meta_new.size); + assert_eq!(meta_old.times, meta_new.times); + assert_eq!(meta_old.first_dir_entry, meta_new.first_dir_entry); + assert_eq!(meta_old.last_dir_entry, meta_new.last_dir_entry); + assert_eq!(meta_old.chunk_type, meta_new.chunk_type); +} + +#[ic_cdk::query] +fn check_metadata_deserialization_into_repr_c() -> u64 { + #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] + pub struct MetadataOld { + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub first_dir_entry: Option, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + #[repr(C)] + #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] + pub struct MetadataReprC { + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub first_dir_entry: Option, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + fn meta_to_bytes(meta: &MetadataOld) -> std::borrow::Cow<[u8]> { + let mut buf = vec![]; + ciborium::ser::into_writer(meta, &mut buf).unwrap(); + std::borrow::Cow::Owned(buf) + } + + fn meta_from_bytes(bytes: std::borrow::Cow<[u8]>) -> MetadataReprC { + ciborium::de::from_reader(bytes.as_ref()).unwrap() + } + + let meta_old = MetadataOld { + node: 23, + file_type: FileType::RegularFile, + link_count: 3, + size: 123, + times: Times::default(), + first_dir_entry: Some(25), + last_dir_entry: Some(35), + chunk_type: Some(stable_fs::fs::ChunkType::V2), + }; + + // serialize from old format + let bytes = meta_to_bytes(&meta_old); + + let stime = ic_cdk::api::instruction_counter(); + // decerialize into C repr + let meta_new = meta_from_bytes(bytes); + let etime = ic_cdk::api::instruction_counter(); + + assert_eq!(meta_old.node, meta_new.node); + assert_eq!(meta_old.file_type, meta_new.file_type); + assert_eq!(meta_old.link_count, meta_new.link_count); + assert_eq!(meta_old.size, meta_new.size); + assert_eq!(meta_old.times, meta_new.times); + assert_eq!(meta_old.first_dir_entry, meta_new.first_dir_entry); + assert_eq!(meta_old.last_dir_entry, meta_new.last_dir_entry); + assert_eq!(meta_old.chunk_type, meta_new.chunk_type); + + etime - stime +} + +#[ic_cdk::query] +fn check_metadata_binary() -> String { + // 1. Allocate "uninitialized" memory for a Metadata + let mut uninit = MaybeUninit::::uninit(); + + // 2. Fill that memory with 0xfa + unsafe { + ptr::write_bytes( + uninit.as_mut_ptr() as *mut u8, + 0xfa, + mem::size_of::(), + ); + } + + // 3. Now "create" the actual Metadata from that memory + // (this is only safe if every field of Metadata is + // assigned a valid value afterwards) + let mut meta = unsafe { uninit.assume_init() }; + + // 4. Overwrite the fields with actual values + meta.node = 3; + meta.file_type = FileType::RegularFile; + meta.link_count = 6; + meta.size = 8; + meta.times = Times { + accessed: 65u64, + modified: 66u64, + created: 67u64, + }; + meta.first_dir_entry = Some(12); + meta.last_dir_entry = Some(13); + meta.chunk_type = Some(stable_fs::fs::ChunkType::V2); + meta.maximum_size_allowed = Some(0xcdab); + + let vec = to_binary(&meta); + hex::encode(&vec) +} diff --git a/tests/canister_upgraded/Cargo.lock b/tests/canister_upgraded/Cargo.lock index e645e3d..ff39160 100644 --- a/tests/canister_upgraded/Cargo.lock +++ b/tests/canister_upgraded/Cargo.lock @@ -1,6 +1,6 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 +version = 4 [[package]] name = "anyhow" @@ -104,9 +104,13 @@ name = "canister_upgraded_backend" version = "0.1.0" dependencies = [ "candid", - "ic-cdk 0.15.0", + "ciborium", + "hex", + "ic-cdk", "ic-cdk-timers", "ic-stable-structures", + "serde", + "serde_bytes", "stable-fs", ] @@ -320,32 +324,6 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" -[[package]] -name = "ic-cdk" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8859bc2b863a77750acf199e1fb7e3fc403e1b475855ba13f59cb4e4036d238" -dependencies = [ - "candid", - "ic-cdk-macros 0.13.2", - "ic0 0.21.1", - "serde", - "serde_bytes", -] - -[[package]] -name = "ic-cdk" -version = "0.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c44983d6e97135d86132111bae5b86c34c498d96b4f182638bebcc7ac07e03c" -dependencies = [ - "candid", - "ic-cdk-macros 0.15.0", - "ic0 0.23.0", - "serde", - "serde_bytes", -] - [[package]] name = "ic-cdk" version = "0.17.1" @@ -353,40 +331,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "122efbcb0af5280d408a75a57b7dc6e9d92893bf6ed9cc98fe4dcff51f18b67c" dependencies = [ "candid", - "ic-cdk-macros 0.17.1", - "ic0 0.23.0", + "ic-cdk-macros", + "ic0", "serde", "serde_bytes", ] -[[package]] -name = "ic-cdk-macros" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a45800053d80a6df839a71aaea5797e723188c0b992618208ca3b941350c7355" -dependencies = [ - "candid", - "proc-macro2", - "quote", - "serde", - "serde_tokenstream 0.1.7", - "syn 1.0.109", -] - -[[package]] -name = "ic-cdk-macros" -version = "0.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3af44fb4ec3a4b18831c9d3303ca8fa2ace846c4022d50cb8df4122635d3782e" -dependencies = [ - "candid", - "proc-macro2", - "quote", - "serde", - "serde_tokenstream 0.2.1", - "syn 2.0.91", -] - [[package]] name = "ic-cdk-macros" version = "0.17.1" @@ -397,19 +347,19 @@ dependencies = [ "proc-macro2", "quote", "serde", - "serde_tokenstream 0.2.1", + "serde_tokenstream", "syn 2.0.91", ] [[package]] name = "ic-cdk-timers" -version = "0.7.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "054727a3a1c486528b96349817d54290ff70df6addf417def456ea708a16f7fb" +checksum = "fb8fd812a9e26f6aa00594546f8fbf4d4853f39c3ba794c8ff11ecf86fd3c9e4" dependencies = [ "futures", - "ic-cdk 0.13.2", - "ic0 0.21.1", + "ic-cdk", + "ic0", "serde", "serde_bytes", "slotmap", @@ -424,12 +374,6 @@ dependencies = [ "ic_principal", ] -[[package]] -name = "ic0" -version = "0.21.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a54b5297861c651551676e8c43df805dad175cc33bc97dbd992edbbb85dcbcdf" - [[package]] name = "ic0" version = "0.23.0" @@ -566,44 +510,33 @@ checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6" [[package]] name = "serde" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e" +checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70" dependencies = [ "serde_derive", ] [[package]] name = "serde_bytes" -version = "0.11.14" +version = "0.11.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734" +checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a" dependencies = [ "serde", ] [[package]] name = "serde_derive" -version = "1.0.216" +version = "1.0.217" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e" +checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0" dependencies = [ "proc-macro2", "quote", "syn 2.0.91", ] -[[package]] -name = "serde_tokenstream" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "797ba1d80299b264f3aac68ab5d12e5825a561749db4df7cd7c8083900c5d4e9" -dependencies = [ - "proc-macro2", - "serde", - "syn 1.0.109", -] - [[package]] name = "serde_tokenstream" version = "0.2.1" @@ -647,11 +580,11 @@ dependencies = [ [[package]] name = "stable-fs" -version = "0.6.5" +version = "0.7.0" dependencies = [ "bitflags", "ciborium", - "ic-cdk 0.17.1", + "ic-cdk", "ic-stable-structures", "serde", "serde_bytes", diff --git a/tests/canister_upgraded/src/canister_upgraded_backend/Cargo.toml b/tests/canister_upgraded/src/canister_upgraded_backend/Cargo.toml index 6d2bdbf..271de13 100644 --- a/tests/canister_upgraded/src/canister_upgraded_backend/Cargo.toml +++ b/tests/canister_upgraded/src/canister_upgraded_backend/Cargo.toml @@ -10,7 +10,13 @@ crate-type = ["cdylib"] [dependencies] candid = "0.10" -ic-cdk = "0.15" -ic-cdk-timers = "0.7" # Feel free to remove this dependency if you don't need timers -ic-stable-structures = "0.6.5" +ic-cdk = "0.17" +ic-cdk-timers = "0.11" # Feel free to remove this dependency if you don't need timers +ic-stable-structures = "0.6.7" stable-fs = {path="../../../../../stable-fs"} + + +serde = "1.0.216" +serde_bytes = "0.11.15" +ciborium = "0.2.2" +hex = "0.4" diff --git a/tests/canister_upgraded/src/canister_upgraded_backend/src/lib.rs b/tests/canister_upgraded/src/canister_upgraded_backend/src/lib.rs index b831975..9d50819 100644 --- a/tests/canister_upgraded/src/canister_upgraded_backend/src/lib.rs +++ b/tests/canister_upgraded/src/canister_upgraded_backend/src/lib.rs @@ -1,15 +1,36 @@ use std::{cell::RefCell, str::FromStr}; -use stable_fs::{fs::{DstBuf, FdStat, FileSystem, OpenFlags, SrcBuf, Whence}, storage::stable::StableStorage}; -use ic_stable_structures::{memory_manager::{MemoryId, MemoryManager}, DefaultMemoryImpl, Memory}; - +use ic_stable_structures::{ + memory_manager::{MemoryId, MemoryManager}, + DefaultMemoryImpl, Memory, +}; + +use hex; +use ic_cdk::api::stable::WASM_PAGE_SIZE_IN_BYTES; +use ic_stable_structures::VectorMemory; +use serde::Deserialize; +use serde::Serialize; +use stable_fs::fs::ChunkType; +use stable_fs::storage::types::DirEntryIndex; +use stable_fs::storage::types::FileSize; +use stable_fs::storage::types::FileType; +use stable_fs::storage::types::Metadata; +use stable_fs::storage::types::Node; +use stable_fs::storage::types::Times; +use std::mem; +use std::mem::MaybeUninit; +use std::ptr; + +use stable_fs::{ + fs::{DstBuf, FdStat, FileSystem, OpenFlags, SrcBuf, Whence}, + storage::stable::StableStorage, +}; #[ic_cdk::query] fn greet(name: String) -> String { format!("Greetings, {}!", name) } - #[ic_cdk::query] fn greet_times(name: String, times: usize) -> Vec { let mut res = Vec::new(); @@ -21,7 +42,6 @@ fn greet_times(name: String, times: usize) -> Vec { res } - const PROFILING: MemoryId = MemoryId::new(100); thread_local! { @@ -34,7 +54,7 @@ thread_local! { let memory_manager = m.borrow(); let storage = StableStorage::new_with_memory_manager(&memory_manager, 200..210u8); - + let fs = RefCell::new( FileSystem::new(Box::new(storage)).unwrap() ); @@ -52,7 +72,6 @@ thread_local! { #[ic_cdk::update] pub fn append_buffer(text: String, times: usize) -> usize { - BUFFER.with(|buffer| { let mut buffer = buffer.borrow_mut(); @@ -72,7 +91,6 @@ pub fn append_buffer(text: String, times: usize) -> usize { #[ic_cdk::update] pub fn clear_buffer() { - BUFFER.with(|chunk| { let mut chunk = chunk.borrow_mut(); @@ -93,19 +111,19 @@ pub fn clear_buffer() { #[ic_cdk::update] pub fn read_buffer(offset: usize, size: usize) -> String { - BUFFER.with(|chunk| { let mut chunk = chunk.borrow_mut(); let chunk = chunk.as_mut().unwrap(); - std::str::from_utf8(&chunk[offset..offset+size]).unwrap().to_string() + std::str::from_utf8(&chunk[offset..offset + size]) + .unwrap() + .to_string() }) } #[ic_cdk::update] pub fn chunk_size() -> usize { - BUFFER.with(|chunk| { let mut chunk = chunk.borrow_mut(); @@ -117,12 +135,11 @@ pub fn chunk_size() -> usize { #[ic_cdk::update] pub fn store_buffer(filename: String) -> (u64, usize) { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); let res = BUFFER.with(|chunk| { - let chunk = chunk.borrow_mut(); - + let chunk = chunk.as_ref().unwrap(); FS.with(|fs| { @@ -130,14 +147,14 @@ pub fn store_buffer(filename: String) -> (u64, usize) { let root_fd = (*fs).root_fd(); - let fd = (*fs).open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42).unwrap(); + let fd = (*fs) + .open(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) + .unwrap(); - let write_content = [ - SrcBuf { - buf: chunk.as_ptr(), - len: chunk.len(), - }, - ]; + let write_content = [SrcBuf { + buf: chunk.as_ptr(), + len: chunk.len(), + }]; let res = (*fs).write_vec(fd, write_content.as_ref()).unwrap(); @@ -145,19 +162,18 @@ pub fn store_buffer(filename: String) -> (u64, usize) { }) }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); (etime - stime, res) } #[ic_cdk::update] pub fn load_buffer(filename: String) -> (u64, usize) { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); let res = BUFFER.with(|chunk| { - let mut chunk = chunk.borrow_mut(); - + let chunk = chunk.as_mut().unwrap(); FS.with(|fs| { @@ -165,20 +181,20 @@ pub fn load_buffer(filename: String) -> (u64, usize) { let root_fd = (*fs).root_fd(); - let fd = (*fs).open_or_create(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42).unwrap(); + let fd = (*fs) + .open(root_fd, &filename, FdStat::default(), OpenFlags::CREATE, 42) + .unwrap(); let size = (*fs).seek(fd, 0, Whence::END).unwrap() as usize; (*fs).seek(fd, 0, Whence::SET).unwrap(); - let read_content = [ - DstBuf { - buf: chunk.as_mut_ptr(), - len: size, - }, - ]; + let read_content = [DstBuf { + buf: chunk.as_mut_ptr(), + len: size, + }]; - unsafe {chunk.set_len(size)}; + unsafe { chunk.set_len(size) }; let res = (*fs).read_vec(fd, &read_content).unwrap(); @@ -186,12 +202,11 @@ pub fn load_buffer(filename: String) -> (u64, usize) { }) }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); (etime - stime, res) } - pub fn profiling_init() { let memory = MEMORY_MANAGER.with(|m| m.borrow().get(PROFILING)); memory.grow(4096); @@ -208,10 +223,9 @@ fn init() { #[ic_cdk::update] fn write_kib_text(filename: String, kb_size: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -219,17 +233,21 @@ fn write_kib_text(filename: String, kb_size: usize) -> u64 { // 64 byte block let text = "0123456789012345678901234567890123456789012345678901234567890123"; - let write_content = [ - SrcBuf { - buf: text.as_ptr(), - len: text.len(), - }, - ]; - + let write_content = [SrcBuf { + buf: text.as_ptr(), + len: text.len(), + }]; + let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); let times = 1024 * kb_size / text.len(); @@ -237,45 +255,47 @@ fn write_kib_text(filename: String, kb_size: usize) -> u64 { for _ in 0..times { fs.write_vec(fd, write_content.as_ref()).unwrap(); } - - let _ = fs.close(fd); + let _ = fs.close(fd); }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } - #[ic_cdk::update] fn write_mib_text(filename: String, mib_size: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); // create 4kib block - let mut text1kib = "0123456789012345678901234567890123456789012345678901234567890123".to_string(); + let mut text1kib = + "0123456789012345678901234567890123456789012345678901234567890123".to_string(); while text1kib.len() < 4096 { text1kib.push_str(&text1kib.clone()); } - let write_content = [ - SrcBuf { - buf: text1kib.as_ptr(), - len: text1kib.len(), - }, - ]; - + let write_content = [SrcBuf { + buf: text1kib.as_ptr(), + len: text1kib.len(), + }]; + let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); let times = 1024 * 1024 * mib_size / text1kib.len(); @@ -283,58 +303,58 @@ fn write_mib_text(filename: String, mib_size: usize) -> u64 { for _ in 0..times { fs.write_vec(fd, write_content.as_ref()).unwrap(); } - - let _ = fs.close(fd); + let _ = fs.close(fd); }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } #[ic_cdk::update] fn read_bytes(filename: String, offset: i64, size: usize) -> (u64, usize) { - - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); let mut res = Vec::with_capacity(size); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::empty(), 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); + + let read_content = [DstBuf { + buf: res.as_mut_ptr(), + len: size, + }]; + + let len = fs + .read_vec_with_offset(fd, &read_content, offset as u64) .unwrap(); - let read_content = [ - DstBuf { - buf: res.as_mut_ptr(), - len: size, - }, - ]; - - let len = fs.read_vec_with_offset(fd, &read_content, offset as u64).unwrap(); - let _ = fs.close(fd); - unsafe {res.set_len(len as usize)}; - + unsafe { res.set_len(len as usize) }; }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); (etime - stime, res.len()) } - // delete file #[ic_cdk::query] fn delete_file(filename: String) { FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -346,7 +366,6 @@ fn delete_file(filename: String) { #[ic_cdk::query] fn delete_folder(filename: String) { FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -354,52 +373,59 @@ fn delete_folder(filename: String) { }); } - #[ic_cdk::query] fn list_files(path: String) -> Vec { let mut res = vec![]; FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); - let fd = fs.open_or_create(dir, path.as_str(), FdStat::default(), OpenFlags::DIRECTORY, 0).unwrap(); + let fd = fs + .open( + dir, + path.as_str(), + FdStat::default(), + OpenFlags::DIRECTORY, + 0, + ) + .unwrap(); let meta = fs.metadata(fd).unwrap(); let mut entry_index = meta.first_dir_entry; while let Some(index) = entry_index { - let entry = fs.get_direntry(fd, index).unwrap(); - let filename_str = std::str::from_utf8(&entry.name.bytes[0..(entry.name.length as usize)]).unwrap(); + let filename_str = + std::str::from_utf8(&entry.name.bytes[0..(entry.name.length as usize)]).unwrap(); let st = String::from_str(filename_str).unwrap(); res.push(st); entry_index = entry.next_entry; - } - }); res } - #[ic_cdk::query] fn cat_file(filename: String) -> String { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); let fd = fs - .open_or_create(dir, filename.as_str() , FdStat::default(), OpenFlags::empty(), 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) .unwrap(); let mut buf = [0u8; 100]; @@ -416,77 +442,75 @@ fn cat_file(filename: String) -> String { #[ic_cdk::update] fn create_depth_folders(path: String, count: usize) -> String { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); let root_dir = fs.root_fd(); let mut dir_name = "d0".to_string(); - + for num in 1..count { dir_name = format!("{}/d{}", dir_name, num); } - fs.create_dir(root_dir, dir_name.as_str(), FdStat::default(), 0).unwrap(); + fs.mkdir(root_dir, dir_name.as_str(), FdStat::default(), 0) + .unwrap(); format!("{}/{}", path, dir_name) - }) } #[ic_cdk::update] fn create_files(path: String, count: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); + let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); for num in 0..count { - let filename = format!("{}/{}.txt", path, num); let fd = fs - .open_or_create(dir, filename.as_str() , FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); // 64 byte block - let text = format!("0123456789012345678901234567890123456789012345678901234567890123:{}", filename); - - let write_content = [ - SrcBuf { - buf: text.as_ptr(), - len: text.len(), - }, - ]; - + let text = format!( + "0123456789012345678901234567890123456789012345678901234567890123:{}", + filename + ); + + let write_content = [SrcBuf { + buf: text.as_ptr(), + len: text.len(), + }]; + fs.write_vec(fd, write_content.as_ref()).unwrap(); - - let _ = fs.close(fd); + let _ = fs.close(fd); } - }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } - #[ic_cdk::update] fn append_text(filename: String, text: String, times: usize) -> u64 { - let stime = ic_cdk::api::instruction_counter(); FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); @@ -497,71 +521,85 @@ fn append_text(filename: String, text: String, times: usize) -> u64 { txt.push_str(&text); } - let write_content = [ - SrcBuf { - buf: txt.as_ptr(), - len: txt.len(), - }, - ]; - + let write_content = [SrcBuf { + buf: txt.as_ptr(), + len: txt.len(), + }]; + let fd = fs - .open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::CREATE, 0) + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::CREATE, + 0, + ) .unwrap(); - + let _ = fs.seek(fd, 0, Whence::END); fs.write_vec(fd, write_content.as_ref()).unwrap(); - - let _ = fs.close(fd); + let _ = fs.close(fd); }); - let etime = ic_cdk::api::instruction_counter(); + let etime = ic_cdk::api::instruction_counter(); etime - stime } - #[ic_cdk::query] fn read_text(filename: String, offset: i64, size: usize) -> String { - FS.with(|fs| { let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); - let fd = fs.open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::empty(), 0).unwrap(); + let fd = fs + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); let mut content = (0..size).map(|_| ".").collect::(); - let read_content = [ - DstBuf { - buf: content.as_mut_ptr(), - len: content.len(), - }, - ]; - - let read = fs.read_vec_with_offset(fd, &read_content, offset as u64).unwrap(); + let read_content = [DstBuf { + buf: content.as_mut_ptr(), + len: content.len(), + }]; + + let read = fs + .read_vec_with_offset(fd, &read_content, offset as u64) + .unwrap(); let min = std::cmp::min(read, size as u64) as usize; - + let _ = fs.close(fd); content[..min].to_string() }) - } #[ic_cdk::query] fn file_size(filename: String) -> usize { - FS.with(|fs| { - let mut fs = fs.borrow_mut(); let dir = fs.root_fd(); - let fd = fs.open_or_create(dir, filename.as_str(), FdStat::default(), OpenFlags::empty(), 0).unwrap(); + let fd = fs + .open( + dir, + filename.as_str(), + FdStat::default(), + OpenFlags::empty(), + 0, + ) + .unwrap(); let meta = fs.metadata(fd).unwrap(); @@ -569,4 +607,203 @@ fn file_size(filename: String) -> usize { size as usize }) -} \ No newline at end of file +} + +pub fn new_vector_memory() -> VectorMemory { + use std::{cell::RefCell, rc::Rc}; + + Rc::new(RefCell::new(Vec::new())) +} + +#[inline] +pub fn grow_memory(memory: &dyn Memory, max_address: FileSize) { + let pages_required = max_address.div_ceil(WASM_PAGE_SIZE_IN_BYTES); + + let cur_pages = memory.size(); + + if cur_pages < pages_required { + memory.grow(pages_required - cur_pages); + } +} + +#[inline] +pub fn read_obj(memory: &dyn Memory, address: u64, obj: &mut T) { + let obj_size = std::mem::size_of::(); + + let obj_bytes = unsafe { std::slice::from_raw_parts_mut(obj as *mut T as *mut u8, obj_size) }; + + memory.read(address, obj_bytes); +} + +#[inline] +pub fn write_obj(memory: &dyn Memory, address: u64, obj: &T) { + let obj_size = std::mem::size_of::(); + + let obj_bytes = unsafe { std::slice::from_raw_parts(obj as *const T as *const u8, obj_size) }; + + grow_memory(memory, address + obj_size as u64); + + memory.write(address, obj_bytes); +} + +#[inline] +pub fn to_binary(obj: &T) -> Vec { + let obj_size = std::mem::size_of::(); + + let obj_bytes = unsafe { std::slice::from_raw_parts(obj as *const T as *const u8, obj_size) }; + + let ret: Vec = obj_bytes.to_vec(); + + ret +} + +#[ic_cdk::query] +fn check_metadata_format() { + #[repr(C)] + #[derive(Clone, Debug, Default, PartialEq)] + pub struct MetadataC { + pub first_dir_entry: Option, + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + let mem = new_vector_memory(); + + let meta_old = Metadata { + node: 23, + file_type: FileType::RegularFile, + link_count: 3, + size: 123, + times: Times::default(), + first_dir_entry: Some(24), + last_dir_entry: Some(35), + chunk_type: Some(stable_fs::fs::ChunkType::V2), + maximum_size_allowed: None, + }; + + write_obj(&mem, 16, &meta_old); + + let mut meta_new = MetadataC::default(); + + read_obj(&mem, 16, &mut meta_new); + + assert_eq!(meta_old.node, meta_new.node); + assert_eq!(meta_old.file_type, meta_new.file_type); + assert_eq!(meta_old.link_count, meta_new.link_count); + assert_eq!(meta_old.size, meta_new.size); + assert_eq!(meta_old.times, meta_new.times); + assert_eq!(meta_old.first_dir_entry, meta_new.first_dir_entry); + assert_eq!(meta_old.last_dir_entry, meta_new.last_dir_entry); + assert_eq!(meta_old.chunk_type, meta_new.chunk_type); +} + +#[ic_cdk::query] +fn check_metadata_deserialization_into_repr_c() -> u64 { + #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] + pub struct MetadataOld { + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub first_dir_entry: Option, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + #[repr(C)] + #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] + pub struct MetadataReprC { + pub node: Node, + pub file_type: FileType, + pub link_count: u64, + pub size: FileSize, + pub times: Times, + pub first_dir_entry: Option, + pub last_dir_entry: Option, + pub chunk_type: Option, + } + + fn meta_to_bytes(meta: &MetadataOld) -> std::borrow::Cow<[u8]> { + let mut buf = vec![]; + ciborium::ser::into_writer(meta, &mut buf).unwrap(); + std::borrow::Cow::Owned(buf) + } + + fn meta_from_bytes(bytes: std::borrow::Cow<[u8]>) -> MetadataReprC { + ciborium::de::from_reader(bytes.as_ref()).unwrap() + } + + let meta_old = MetadataOld { + node: 23, + file_type: FileType::RegularFile, + link_count: 3, + size: 123, + times: Times::default(), + first_dir_entry: Some(25), + last_dir_entry: Some(35), + chunk_type: Some(stable_fs::fs::ChunkType::V2), + }; + + // serialize from old format + let bytes = meta_to_bytes(&meta_old); + + let stime = ic_cdk::api::instruction_counter(); + // decerialize into C repr + let meta_new = meta_from_bytes(bytes); + let etime = ic_cdk::api::instruction_counter(); + + assert_eq!(meta_old.node, meta_new.node); + assert_eq!(meta_old.file_type, meta_new.file_type); + assert_eq!(meta_old.link_count, meta_new.link_count); + assert_eq!(meta_old.size, meta_new.size); + assert_eq!(meta_old.times, meta_new.times); + assert_eq!(meta_old.first_dir_entry, meta_new.first_dir_entry); + assert_eq!(meta_old.last_dir_entry, meta_new.last_dir_entry); + assert_eq!(meta_old.chunk_type, meta_new.chunk_type); + + etime - stime +} + +#[ic_cdk::query] +fn check_metadata_binary() -> String { + // 1. Allocate "uninitialized" memory for a Metadata + let mut uninit = MaybeUninit::::uninit(); + + // 2. Fill that memory with 0xfa + unsafe { + ptr::write_bytes( + uninit.as_mut_ptr() as *mut u8, + 0xfa, + mem::size_of::(), + ); + } + + // 3. Now "create" the actual Metadata from that memory + // (this is only safe if every field of Metadata is + // assigned a valid value afterwards) + let mut meta = unsafe { uninit.assume_init() }; + + // 4. Overwrite the fields with actual values + meta.node = 3; + meta.file_type = FileType::RegularFile; + meta.link_count = 6; + meta.size = 8; + meta.times = Times { + accessed: 65u64, + modified: 66u64, + created: 67u64, + }; + meta.first_dir_entry = Some(12); + meta.last_dir_entry = Some(13); + meta.chunk_type = Some(stable_fs::fs::ChunkType::V2); + meta.maximum_size_allowed = Some(0xcdab); + + let vec = to_binary(&meta); + hex::encode(&vec) +} diff --git a/tests/svg/perf_write_10mb_segments.svg b/tests/svg/perf_write_10mb_segments.svg deleted file mode 100644 index fe7c3e8..0000000 --- a/tests/svg/perf_write_10mb_segments.svg +++ /dev/null @@ -1,491 +0,0 @@ -perf_write_10mb_segments Reset ZoomSearch dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (240 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)ic_cdk::api::call::arg_data_raw (1,186 instructions, 0.17%)core::str::pattern::StrSearcher::new (470 instructions, 0.07%)binread::binread_impls::<impl binread::BinRead for [B (976 instructions, 0.14%) 4]>::read_options (976 instructions, 0.14%)leb128::read::unsigned (92 instructions, 0.01%)candid::binary_parser::read_leb (129 instructions, 0.02%)core::str::pattern::StrSearcher::new (470 instructions, 0.07%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)memcpy (76 instructions, 0.01%)<alloc::string::String as core::fmt::Write>::write_str (105 instructions, 0.02%)<alloc::string::String as core::fmt::Write>::write_str (73 instructions, 0.01%)core::fmt::Formatter::pad_integral (151 instructions, 0.02%)core::fmt::num::imp::fmt_u64 (218 instructions, 0.03%)core::fmt::num::imp::<impl core::fmt::Display for u32>::fmt (228 instructions, 0.03%)core::fmt::write (470 instructions, 0.07%)alloc::fmt::format::format_inner (735 instructions, 0.11%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (109 instructions, 0.02%)binread::binary_template::write_vec (993 instructions, 0.14%)binread::binread_impls::<impl binread::BinRead for alloc::vec::Vec<B>>::read_options (1,693 instructions, 0.25%)leb128::read::unsigned (92 instructions, 0.01%)candid::binary_parser::read_leb (129 instructions, 0.02%)core::str::pattern::StrSearcher::new (470 instructions, 0.07%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)memcpy (76 instructions, 0.01%)<alloc::string::String as core::fmt::Write>::write_str (105 instructions, 0.02%)<alloc::string::String as core::fmt::Write>::write_str (73 instructions, 0.01%)core::fmt::Formatter::pad_integral (151 instructions, 0.02%)core::fmt::num::imp::fmt_u64 (218 instructions, 0.03%)core::fmt::num::imp::<impl core::fmt::Display for u32>::fmt (228 instructions, 0.03%)core::fmt::write (470 instructions, 0.07%)alloc::fmt::format::format_inner (735 instructions, 0.11%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (109 instructions, 0.02%)binread::binary_template::write_vec (993 instructions, 0.14%)leb128::read::signed (120 instructions, 0.02%)candid::binary_parser::read_sleb (157 instructions, 0.02%)<candid::binary_parser::IndexType as binread::BinRead>::read_options (321 instructions, 0.05%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (541 instructions, 0.08%)binread::binread_impls::<impl binread::BinRead for alloc::vec::Vec<B>>::read_options (2,203 instructions, 0.32%)binread::BinRead::read (5,605 instructions, 0.81%)candid::types::type_env::TypeEnv::replace_empty (189 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)candid::binary_parser::IndexType::to_type (223 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)alloc::raw_vec::RawVec<T,A>::grow_one (250 instructions, 0.04%)candid::binary_parser::Header::to_types (875 instructions, 0.13%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<alloc::vec::into_iter::IntoIter<T,A> as core::iter::traits::iterator::Iterator>::fold (217 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (240 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)compiler_builtins::mem::memcpy (506 instructions, 0.07%)memcpy (515 instructions, 0.07%)anyhow::context::<impl anyhow::Context<T,E> for core::result::Result<T,E>>::with_context (546 instructions, 0.08%)compiler_builtins::mem::memcpy (394 instructions, 0.06%)compiler_builtins::mem::memcpy (506 instructions, 0.07%)memcpy (918 instructions, 0.13%)candid::de::IDLDeserialize::new_with_config (9,196 instructions, 1.33%)compiler_builtins::mem::memcpy (410 instructions, 0.06%)compiler_builtins::mem::memcpy (410 instructions, 0.06%)memcpy (838 instructions, 0.12%)std::thread::local::LocalKey<T>::with (147 instructions, 0.02%)candid::types::internal::find_type (155 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<candid::types::internal::Type as core::convert::From<candid::types::internal::TypeInner>>::from (174 instructions, 0.03%)compiler_builtins::mem::memmove (172 instructions, 0.02%)compiler_builtins::mem::memmove (158 instructions, 0.02%)memmove (348 instructions, 0.05%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (470 instructions, 0.07%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (666 instructions, 0.10%)std::thread::local::LocalKey<T>::with (739 instructions, 0.11%)candid::types::internal::env_add (785 instructions, 0.11%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)candid::types::impls::<impl candid::types::CandidType for alloc::string::String>::_ty (141 instructions, 0.02%)compiler_builtins::mem::memcmp (552 instructions, 0.08%)memcmp (561 instructions, 0.08%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (711 instructions, 0.10%)std::thread::local::LocalKey<T>::with (784 instructions, 0.11%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<alloc::rc::Rc<T,A> as core::ops::drop::Drop>::drop (185 instructions, 0.03%)candid::types::internal::env_add (1,023 instructions, 0.15%)std::thread::local::LocalKey<T>::with (258 instructions, 0.04%)candid::types::internal::env_id (304 instructions, 0.04%)candid::types::CandidType::ty (2,707 instructions, 0.39%)dlmalloc::dlmalloc::Dlmalloc<A>::free (140 instructions, 0.02%)__rdl_dealloc (179 instructions, 0.03%)__rust_dealloc (189 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::free (140 instructions, 0.02%)__rdl_dealloc (179 instructions, 0.03%)__rust_dealloc (189 instructions, 0.03%)<alloc::rc::Rc<T,A> as core::ops::drop::Drop>::drop (476 instructions, 0.07%)leb128::read::unsigned (92 instructions, 0.01%)binread::BinRead::read (250 instructions, 0.04%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)compiler_builtins::mem::memcpy (147 instructions, 0.02%)memcpy (156 instructions, 0.02%)<T as alloc::slice::hack::ConvertVec>::to_vec (322 instructions, 0.05%)core::str::converts::from_utf8 (91 instructions, 0.01%)serde::de::impls::<impl serde::de::Deserialize for alloc::string::String>::deserialize (1,014 instructions, 0.15%)candid::de::IDLDeserialize::deserialize_with_type (1,791 instructions, 0.26%)dlmalloc::dlmalloc::Dlmalloc<A>::free (140 instructions, 0.02%)__rdl_dealloc (179 instructions, 0.03%)__rust_dealloc (189 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::free (142 instructions, 0.02%)__rdl_dealloc (181 instructions, 0.03%)__rust_dealloc (191 instructions, 0.03%)<alloc::rc::Rc<T,A> as core::ops::drop::Drop>::drop (240 instructions, 0.03%)candid::utils::decode_args_with_config_debug (15,268 instructions, 2.21%)c..dlmalloc::dlmalloc::Dlmalloc<A>::free (140 instructions, 0.02%)__rdl_dealloc (179 instructions, 0.03%)__rust_dealloc (189 instructions, 0.03%)ic_cdk::api::call::arg_data (16,745 instructions, 2.43%)i..dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)compiler_builtins::mem::memcpy (147 instructions, 0.02%)memcpy (156 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (76 instructions, 0.01%)core::hash::BuildHasher::hash_one (629 instructions, 0.09%)compiler_builtins::mem::memcmp (214 instructions, 0.03%)memcmp (223 instructions, 0.03%)stable_fs::filename_cache::FilenameCache::get (978 instructions, 0.14%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (109 instructions, 0.02%)stable_fs::runtime::structure_helpers::find_node (1,468 instructions, 0.21%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (2,530 instructions, 0.37%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::entry::Entry<K,V,A>::or_default (171 instructions, 0.02%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (117 instructions, 0.02%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (253 instructions, 0.04%)stable_fs::runtime::fd::FdTable::insert (667 instructions, 0.10%)stable_fs::runtime::fd::FdTable::open (715 instructions, 0.10%)stable_fs::fs::FileSystem::open (3,421 instructions, 0.50%)stable_fs::fs::FileSystem::open_or_create (5,011 instructions, 0.73%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)stable_fs::fs::FileSystem::seek (2,622 instructions, 0.38%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1,601 instructions, 0.23%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (2,216 instructions, 0.32%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (5,939 instructions, 0.86%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1,601 instructions, 0.23%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (2,216 instructions, 0.32%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (5,939 instructions, 0.86%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1,601 instructions, 0.23%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (2,216 instructions, 0.32%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (5,939 instructions, 0.86%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1,601 instructions, 0.23%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (2,216 instructions, 0.32%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (5,939 instructions, 0.86%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1,601 instructions, 0.23%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (2,216 instructions, 0.32%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (5,939 instructions, 0.86%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (1,601 instructions, 0.23%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (2,216 instructions, 0.32%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (5,939 instructions, 0.86%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (381 instructions, 0.06%)stable_fs::storage::metadata_cache::MetadataCache::get (605 instructions, 0.09%)compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_metadata (1,265 instructions, 0.18%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_mounted_memory (266 instructions, 0.04%)<core::hash::sip::Hasher<S> as core::hash::Hasher>::write (145 instructions, 0.02%)core::hash::BuildHasher::hash_one (460 instructions, 0.07%)stable_fs::storage::ptr_cache::PtrCache::get (589 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (901 instructions, 0.13%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (1,608 instructions, 0.23%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (4,530 instructions, 0.66%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (195 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (273 instructions, 0.04%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (74 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (214 instructions, 0.03%)stable_fs::runtime::fd::FdTable::insert (1,116 instructions, 0.16%)stable_fs::fs::FileSystem::write_vec (600,654 instructions, 87.13%)stable_fs::fs::FileSystem::write_vecdlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (246 instructions, 0.04%)ciborium_ll::enc::Encoder<W>::push (863 instructions, 0.13%)__rdl_realloc (139 instructions, 0.02%)__rust_realloc (152 instructions, 0.02%)alloc::raw_vec::finish_grow (199 instructions, 0.03%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (285 instructions, 0.04%)__rdl_realloc (139 instructions, 0.02%)__rust_realloc (152 instructions, 0.02%)alloc::raw_vec::finish_grow (199 instructions, 0.03%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (285 instructions, 0.04%)ciborium_ll::enc::Encoder<W>::push (610 instructions, 0.09%)__rdl_realloc (139 instructions, 0.02%)__rust_realloc (152 instructions, 0.02%)alloc::raw_vec::finish_grow (199 instructions, 0.03%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (285 instructions, 0.04%)ciborium_ll::enc::Encoder<W>::push (1,190 instructions, 0.17%)__rdl_realloc (139 instructions, 0.02%)__rust_realloc (152 instructions, 0.02%)alloc::raw_vec::finish_grow (199 instructions, 0.03%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (285 instructions, 0.04%)ciborium_ll::enc::Encoder<W>::push (1,162 instructions, 0.17%)<&mut ciborium::ser::Serializer<W> as serde::ser::Serializer>::serialize_unit_variant (184 instructions, 0.03%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::to_bytes (5,901 instructions, 0.86%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::read (513 instructions, 0.07%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::read (514 instructions, 0.07%)ic_stable_structures::btreemap::node::v2::read_overflows (573 instructions, 0.08%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)compiler_builtins::mem::memset (107 instructions, 0.02%)memset (116 instructions, 0.02%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::read (514 instructions, 0.07%)<ic_stable_structures::btreemap::node::io::NodeReader<M> as ic_stable_structures::Memory>::read_unsafe (685 instructions, 0.10%)<u64 as ic_stable_structures::storable::Storable>::from_bytes (77 instructions, 0.01%)memset (72 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::read (510 instructions, 0.07%)<ic_stable_structures::btreemap::node::io::NodeReader<M> as ic_stable_structures::Memory>::read_unsafe (637 instructions, 0.09%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (109 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (3,315 instructions, 0.48%)memset (72 instructions, 0.01%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::read (510 instructions, 0.07%)<ic_stable_structures::btreemap::node::io::NodeReader<M> as ic_stable_structures::Memory>::read_unsafe (637 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)compiler_builtins::mem::memset (427 instructions, 0.06%)memset (436 instructions, 0.06%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::read (636 instructions, 0.09%)<ic_stable_structures::btreemap::node::io::NodeReader<M> as ic_stable_structures::Memory>::read_unsafe (1,127 instructions, 0.16%)ic_stable_structures::btreemap::node::Value::take_or_load (2,055 instructions, 0.30%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (513 instructions, 0.07%)ic_stable_structures::write (590 instructions, 0.09%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (514 instructions, 0.07%)ic_stable_structures::write (591 instructions, 0.09%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (1,299 instructions, 0.19%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<f64 as ic_stable_structures::storable::Storable>::to_bytes (191 instructions, 0.03%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (514 instructions, 0.07%)ic_stable_structures::write (591 instructions, 0.09%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (650 instructions, 0.09%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (109 instructions, 0.02%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (510 instructions, 0.07%)ic_stable_structures::write (587 instructions, 0.09%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (636 instructions, 0.09%)ic_stable_structures::write (713 instructions, 0.10%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (1,418 instructions, 0.21%)<ic_stable_structures::memory_manager::BucketIterator as core::iter::traits::iterator::Iterator>::next (85 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (514 instructions, 0.07%)ic_stable_structures::write (591 instructions, 0.09%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::deallocate_unused_pages (675 instructions, 0.10%)ic_stable_structures::btreemap::node::Node<K>::save (4,866 instructions, 0.71%)compiler_builtins::mem::memset (11,313 instructions, 1.64%)memset (11,322 instructions, 1.64%)ciborium_ll::dec::Decoder<R>::pull (484 instructions, 0.07%)compiler_builtins::mem::memcpy (83 instructions, 0.01%)memcpy (92 instructions, 0.01%)core::str::converts::from_utf8 (128 instructions, 0.02%)ciborium_ll::dec::Decoder<R>::pull (236 instructions, 0.03%)ciborium::de::Deserializer<R>::integer (310 instructions, 0.04%)serde::de::MapAccess::next_value (367 instructions, 0.05%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (163 instructions, 0.02%)memcpy (172 instructions, 0.02%)core::str::converts::from_utf8 (104 instructions, 0.02%)compiler_builtins::mem::memcmp (240 instructions, 0.03%)memcmp (249 instructions, 0.04%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::Metadata>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (274 instructions, 0.04%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)ciborium_ll::dec::Decoder<R>::pull (148 instructions, 0.02%)compiler_builtins::mem::memcpy (195 instructions, 0.03%)memcpy (204 instructions, 0.03%)core::str::converts::from_utf8 (136 instructions, 0.02%)compiler_builtins::mem::memcmp (292 instructions, 0.04%)memcmp (301 instructions, 0.04%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::FileType>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (324 instructions, 0.05%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_identifier (957 instructions, 0.14%)stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::FileType>::deserialize (1,429 instructions, 0.21%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (179 instructions, 0.03%)memcpy (188 instructions, 0.03%)core::str::converts::from_utf8 (120 instructions, 0.02%)compiler_builtins::mem::memcmp (266 instructions, 0.04%)memcmp (275 instructions, 0.04%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::Metadata>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (300 instructions, 0.04%)ciborium_ll::dec::Decoder<R>::pull (236 instructions, 0.03%)ciborium::de::Deserializer<R>::integer (310 instructions, 0.04%)serde::de::MapAccess::next_value (367 instructions, 0.05%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (83 instructions, 0.01%)memcpy (92 instructions, 0.01%)core::str::converts::from_utf8 (128 instructions, 0.02%)ciborium_ll::dec::Decoder<R>::pull (236 instructions, 0.03%)ciborium::de::Deserializer<R>::integer (310 instructions, 0.04%)serde::de::MapAccess::next_value (367 instructions, 0.05%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (99 instructions, 0.01%)memcpy (108 instructions, 0.02%)core::str::converts::from_utf8 (144 instructions, 0.02%)compiler_builtins::mem::memcmp (136 instructions, 0.02%)memcmp (145 instructions, 0.02%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::Metadata>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (169 instructions, 0.02%)ciborium_ll::dec::Decoder<R>::pull (484 instructions, 0.07%)compiler_builtins::mem::memcpy (147 instructions, 0.02%)memcpy (156 instructions, 0.02%)core::str::converts::from_utf8 (91 instructions, 0.01%)ciborium_ll::dec::Decoder<R>::pull (236 instructions, 0.03%)ciborium::de::Deserializer<R>::integer (310 instructions, 0.04%)serde::de::MapAccess::next_value (367 instructions, 0.05%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (147 instructions, 0.02%)memcpy (156 instructions, 0.02%)core::str::converts::from_utf8 (91 instructions, 0.01%)ciborium_ll::dec::Decoder<R>::pull (236 instructions, 0.03%)ciborium::de::Deserializer<R>::integer (310 instructions, 0.04%)serde::de::MapAccess::next_value (367 instructions, 0.05%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (131 instructions, 0.02%)memcpy (140 instructions, 0.02%)core::str::converts::from_utf8 (176 instructions, 0.03%)compiler_builtins::mem::memcmp (188 instructions, 0.03%)memcmp (197 instructions, 0.03%)ciborium_ll::dec::Decoder<R>::pull (236 instructions, 0.03%)ciborium::de::Deserializer<R>::integer (310 instructions, 0.04%)serde::de::MapAccess::next_value (367 instructions, 0.05%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (3,788 instructions, 0.55%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (259 instructions, 0.04%)memcpy (268 instructions, 0.04%)core::str::converts::from_utf8 (200 instructions, 0.03%)compiler_builtins::mem::memcmp (396 instructions, 0.06%)memcmp (405 instructions, 0.06%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::Metadata>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (429 instructions, 0.06%)ciborium_ll::dec::Decoder<R>::pull (233 instructions, 0.03%)serde::de::impls::<impl serde::de::Deserialize for core::option::Option<T>>::deserialize (299 instructions, 0.04%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (243 instructions, 0.04%)memcpy (252 instructions, 0.04%)core::str::converts::from_utf8 (184 instructions, 0.03%)compiler_builtins::mem::memcmp (370 instructions, 0.05%)memcmp (379 instructions, 0.05%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::Metadata>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (403 instructions, 0.06%)ciborium_ll::dec::Decoder<R>::pull (233 instructions, 0.03%)serde::de::impls::<impl serde::de::Deserialize for core::option::Option<T>>::deserialize (299 instructions, 0.04%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)compiler_builtins::mem::memcpy (179 instructions, 0.03%)memcpy (188 instructions, 0.03%)core::str::converts::from_utf8 (120 instructions, 0.02%)compiler_builtins::mem::memcmp (266 instructions, 0.04%)memcmp (305 instructions, 0.04%)<stable_fs::storage::types::_::<impl serde::de::Deserialize for stable_fs::storage::types::Metadata>::deserialize::__FieldVisitor as serde::de::Visitor>::visit_str (344 instructions, 0.05%)ciborium_ll::dec::Decoder<R>::pull (242 instructions, 0.04%)ciborium_ll::dec::Decoder<R>::pull (148 instructions, 0.02%)ciborium_ll::dec::Decoder<R>::pull (148 instructions, 0.02%)core::str::converts::from_utf8 (96 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_identifier (469 instructions, 0.07%)stable_fs::runtime::types::_::<impl serde::de::Deserialize for stable_fs::runtime::types::ChunkType>::deserialize (856 instructions, 0.12%)serde::de::impls::<impl serde::de::Deserialize for core::option::Option<T>>::deserialize (1,271 instructions, 0.18%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 2.40%)<..compiler_builtins::mem::memcpy (346 instructions, 0.05%)memcpy (355 instructions, 0.05%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,422 instructions, 4.12%)<st..dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::free (115 instructions, 0.02%)__rdl_dealloc (154 instructions, 0.02%)__rust_dealloc (300 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,145 instructions, 6.55%)ic_stab..<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,230 instructions, 6.56%)<stable..alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (335 instructions, 0.05%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (378 instructions, 0.05%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::KV>>::remove_leaf_kv (174 instructions, 0.03%)alloc::collections::btree::remove::<impl alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::LeafOrInternal>,alloc::collections::btree::node::marker::KV>>::remove_kv_tracking (219 instructions, 0.03%)alloc::collections::btree::map::entry::OccupiedEntry<K,V,A>::remove_kv (815 instructions, 0.12%)stable_fs::runtime::fd::FdTable::close (1,171 instructions, 0.17%)stable_fs::fs::FileSystem::close (46,551 instructions, 6.75%)stable_..std::thread::local::LocalKey<T>::with (660,503 instructions, 95.82%)std::thread::local::LocalKey<T>::withdlmalloc::dlmalloc::Dlmalloc<A>::insert_large_chunk (133 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::free (307 instructions, 0.04%)__rdl_dealloc (346 instructions, 0.05%)__rust_dealloc (356 instructions, 0.05%)dlmalloc::dlmalloc::Dlmalloc<A>::free (152 instructions, 0.02%)__rdl_dealloc (191 instructions, 0.03%)__rust_dealloc (201 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::free (81 instructions, 0.01%)__rdl_dealloc (120 instructions, 0.02%)__rust_dealloc (130 instructions, 0.02%)<alloc::rc::Rc<T,A> as core::ops::drop::Drop>::drop (614 instructions, 0.09%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<alloc::collections::btree::map::BTreeMap<K,V,A> as core::ops::drop::Drop>::drop (956 instructions, 0.14%)candid::ser::IDLBuilder::new (1,041 instructions, 0.15%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (98 instructions, 0.01%)__rdl_alloc (110 instructions, 0.02%)__rust_alloc (121 instructions, 0.02%)<candid::types::internal::Type as core::convert::From<candid::types::internal::TypeInner>>::from (175 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (216 instructions, 0.03%)std::thread::local::LocalKey<T>::with (289 instructions, 0.04%)candid::types::internal::env_add (335 instructions, 0.05%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)candid::types::impls::<impl candid::types::CandidType for u64>::_ty (141 instructions, 0.02%)compiler_builtins::mem::memcmp (84 instructions, 0.01%)memcmp (93 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (243 instructions, 0.04%)std::thread::local::LocalKey<T>::with (316 instructions, 0.05%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<alloc::rc::Rc<T,A> as core::ops::drop::Drop>::drop (185 instructions, 0.03%)candid::types::internal::env_add (555 instructions, 0.08%)std::thread::local::LocalKey<T>::with (189 instructions, 0.03%)candid::types::internal::env_id (235 instructions, 0.03%)candid::types::CandidType::ty (1,632 instructions, 0.24%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)alloc::raw_vec::RawVec<T,A>::grow_one (250 instructions, 0.04%)candid::ser::TypeSerialize::build_type (114 instructions, 0.02%)candid::ser::TypeSerialize::push_type (416 instructions, 0.06%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (246 instructions, 0.04%)<&mut candid::ser::ValueSerializer as candid::types::Serializer>::serialize_int64 (282 instructions, 0.04%)std::thread::local::LocalKey<T>::with (143 instructions, 0.02%)candid::types::internal::find_type (151 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)<candid::types::internal::Type as core::convert::From<candid::types::internal::TypeInner>>::from (174 instructions, 0.03%)alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Mut,K,V,alloc::collections::btree::node::marker::Leaf>,alloc::collections::btree::node::marker::Edge>::insert_recursing (84 instructions, 0.01%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (277 instructions, 0.04%)std::thread::local::LocalKey<T>::with (350 instructions, 0.05%)candid::types::internal::env_add (396 instructions, 0.06%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)candid::types::impls::<impl candid::types::CandidType for u64>::_ty (141 instructions, 0.02%)compiler_builtins::mem::memcmp (136 instructions, 0.02%)memcmp (145 instructions, 0.02%)alloc::collections::btree::map::BTreeMap<K,V,A>::insert (337 instructions, 0.05%)std::thread::local::LocalKey<T>::with (410 instructions, 0.06%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)__rust_dealloc (136 instructions, 0.02%)<alloc::rc::Rc<T,A> as core::ops::drop::Drop>::drop (185 instructions, 0.03%)candid::types::internal::env_add (649 instructions, 0.09%)std::thread::local::LocalKey<T>::with (189 instructions, 0.03%)candid::types::internal::env_id (235 instructions, 0.03%)candid::types::CandidType::ty (1,871 instructions, 0.27%)candid::ser::TypeSerialize::build_type (114 instructions, 0.02%)candid::ser::TypeSerialize::push_type (158 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)compiler_builtins::mem::memcpy (211 instructions, 0.03%)memcpy (220 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_realloc (540 instructions, 0.08%)__rust_realloc (553 instructions, 0.08%)alloc::raw_vec::finish_grow (600 instructions, 0.09%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (686 instructions, 0.10%)<&mut candid::ser::ValueSerializer as candid::types::Serializer>::serialize_int64 (722 instructions, 0.10%)<ic_cdk::api::call::CallReplyWriter as std::io::Write>::write (518 instructions, 0.08%)std::io::Write::write_all (581 instructions, 0.08%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (246 instructions, 0.04%)dlmalloc::dlmalloc::Dlmalloc<A>::malloc (97 instructions, 0.01%)__rdl_alloc (109 instructions, 0.02%)__rust_alloc (120 instructions, 0.02%)alloc::raw_vec::finish_grow (163 instructions, 0.02%)alloc::raw_vec::RawVec<T,A>::reserve::do_reserve_and_handle (246 instructions, 0.04%)candid::ser::TypeSerialize::encode (323 instructions, 0.05%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (109 instructions, 0.02%)candid::ser::TypeSerialize::serialize (1,166 instructions, 0.17%)<ic_cdk::api::call::CallReplyWriter as std::io::Write>::write (518 instructions, 0.08%)<ic_cdk::api::call::CallReplyWriter as std::io::Write>::write (530 instructions, 0.08%)std::io::Write::write_all (1,174 instructions, 0.17%)candid::ser::IDLBuilder::serialize (3,001 instructions, 0.44%)dlmalloc::dlmalloc::Dlmalloc<A>::free (87 instructions, 0.01%)__rdl_dealloc (126 instructions, 0.02%)dlmalloc::dlmalloc::Dlmalloc<A>::free (142 instructions, 0.02%)__rdl_dealloc (181 instructions, 0.03%)__rdl_dealloc (99 instructions, 0.01%)__rust_dealloc (436 instructions, 0.06%)candid::utils::write_args (9,884 instructions, 1.43%)fs_benchmarks_backend::__canister_method_store_buffer_in_1000b_segments::{{closure}} (688,495 instructions, 99.88%)fs_benchmarks_backend::__canister_method_store_buffer_in_1000b_segments::{{closure}}dlmalloc::dlmalloc::Dlmalloc<A>::free (195 instructions, 0.03%)__rdl_dealloc (234 instructions, 0.03%)dlmalloc::dlmalloc::Dlmalloc<A>::free (140 instructions, 0.02%)__rdl_dealloc (179 instructions, 0.03%)__rust_dealloc (433 instructions, 0.06%)ic_cdk::futures::spawn (689,326 instructions, 100.00%)ic_cdk::futures::spawnall (689,348 instructions, 100%)canister_update store_buffer_in_1000b_segments (689,348 instructions, 100.00%)canister_update store_buffer_in_1000b_segments \ No newline at end of file diff --git a/tests/svg/perf_write_1mb_segments_10_files.svg b/tests/svg/perf_write_1mb_segments_10_files.svg deleted file mode 100644 index 8b6b244..0000000 --- a/tests/svg/perf_write_1mb_segments_10_files.svg +++ /dev/null @@ -1,491 +0,0 @@ -perf_write_1mb_segments_10_files Reset ZoomSearch candid::utils::decode_args_with_config_debug (15,212 instructions, 0.01%)ic_cdk::api::call::arg_data (16,636 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,424 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,134 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (42,801 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node_with_index (45,662 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node (46,927 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,424 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,134 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (42,801 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node_with_index (45,662 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node (46,927 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,424 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,134 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (42,801 instructions, 0.04%)ic_stable_structures::btreemap::node::Node<K>::save (12,602 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (14,366 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (24,906 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (26,597 instructions, 0.03%)ic_stable_structures::btreemap::node::Node<K>::save (12,055 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (14,159 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (23,381 instructions, 0.02%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (23,408 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,424 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,134 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,582 instructions, 0.04%)ic_stable_structures::btreemap::node::Node<K>::save (12,055 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,424 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,213 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (61,463 instructions, 0.06%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (61,490 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (12,620 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (55,298 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (57,283 instructions, 0.05%)stable_fs::runtime::structure_helpers::add_dir_entry (191,594 instructions, 0.18%)stable_fs::runtime::structure_helpers::create_path (267,697 instructions, 0.25%)stable_fs::runtime::dir::Dir::create_file (317,240 instructions, 0.30%)stable_fs::fs::FileSystem::create_file (319,769 instructions, 0.30%)stable_fs::fs::FileSystem::open_or_create (366,841 instructions, 0.35%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,947 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,880 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node_with_index (94,177 instructions, 0.09%)stable_fs::runtime::structure_helpers::find_node (95,442 instructions, 0.09%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,947 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,880 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node_with_index (94,177 instructions, 0.09%)stable_fs::runtime::structure_helpers::find_node (95,442 instructions, 0.09%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,947 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (44,880 instructions, 0.04%)ic_stable_structures::btreemap::node::Node<K>::save (16,790 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (19,596 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (31,543 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (33,234 instructions, 0.03%)ic_stable_structures::btreemap::node::Node<K>::save (18,349 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (20,357 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (31,281 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (31,308 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,618 instructions, 0.04%)ic_stable_structures::btreemap::node::Node<K>::save (18,349 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (70,153 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (70,180 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (16,808 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (61,099 instructions, 0.06%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (63,084 instructions, 0.06%)stable_fs::runtime::structure_helpers::add_dir_entry (216,021 instructions, 0.20%)stable_fs::runtime::structure_helpers::create_path (347,278 instructions, 0.33%)stable_fs::runtime::dir::Dir::create_file (445,336 instructions, 0.42%)stable_fs::fs::FileSystem::create_file (448,012 instructions, 0.42%)stable_fs::fs::FileSystem::open_or_create (543,599 instructions, 0.51%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,677 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,983 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,675 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node_with_index (146,174 instructions, 0.14%)stable_fs::runtime::structure_helpers::find_node (147,439 instructions, 0.14%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,677 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,983 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,675 instructions, 0.04%)stable_fs::runtime::structure_helpers::find_node_with_index (146,174 instructions, 0.14%)stable_fs::runtime::structure_helpers::find_node (147,439 instructions, 0.14%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,677 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,983 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (46,675 instructions, 0.04%)ic_stable_structures::btreemap::node::Node<K>::save (20,978 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (23,426 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (36,740 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (38,431 instructions, 0.04%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,803 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (29,633 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (32,169 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (44,861 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (44,888 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,481 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,262 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (26,768 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (81,769 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (81,796 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (20,996 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (66,976 instructions, 0.06%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (68,961 instructions, 0.07%)stable_fs::runtime::structure_helpers::add_dir_entry (249,738 instructions, 0.24%)stable_fs::runtime::structure_helpers::create_path (438,191 instructions, 0.41%)stable_fs::runtime::dir::Dir::create_file (588,246 instructions, 0.55%)stable_fs::fs::FileSystem::create_file (591,179 instructions, 0.56%)stable_fs::fs::FileSystem::open_or_create (738,763 instructions, 0.70%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,605 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,386 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,546 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,692 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,481 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,627 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (13,376 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (50,157 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (206,190 instructions, 0.19%)stable_fs::runtime::structure_helpers::find_node (207,455 instructions, 0.20%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,605 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,386 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,546 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,692 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,481 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,627 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (13,376 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (50,157 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (206,190 instructions, 0.19%)stable_fs::runtime::structure_helpers::find_node (207,455 instructions, 0.20%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,605 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,386 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,546 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,692 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (12,481 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (49,627 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (13,376 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (50,157 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,166 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (27,936 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (42,617 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (44,308 instructions, 0.04%)core::cell::once::OnceCell<T>::try_init (11,178 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,486 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,667 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (51,835 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (51,862 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (15,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (52,182 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (10,720 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,028 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (91,244 instructions, 0.09%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (91,271 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,184 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,853 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,838 instructions, 0.07%)stable_fs::runtime::structure_helpers::add_dir_entry (274,984 instructions, 0.26%)stable_fs::runtime::structure_helpers::create_path (529,332 instructions, 0.50%)stable_fs::runtime::dir::Dir::create_file (739,403 instructions, 0.70%)stable_fs::fs::FileSystem::create_file (742,292 instructions, 0.70%)stable_fs::fs::FileSystem::open_or_create (949,892 instructions, 0.90%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,525 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,306 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,466 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,612 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,547 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (15,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (52,547 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,838 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,619 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (267,448 instructions, 0.25%)stable_fs::runtime::structure_helpers::find_node (268,713 instructions, 0.25%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,525 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,306 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,466 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,612 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,547 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (15,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (52,547 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,838 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,619 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (267,448 instructions, 0.25%)stable_fs::runtime::structure_helpers::find_node (268,713 instructions, 0.25%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,525 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,306 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,466 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,612 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,547 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (15,401 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (52,547 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (14,838 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (51,619 instructions, 0.05%)core::cell::once::OnceCell<T>::try_init (11,277 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (29,354 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (32,446 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (48,494 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (50,185 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,088 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (14,175 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,668 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (40,828 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (44,331 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (61,392 instructions, 0.06%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (61,419 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (13,750 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,600 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,381 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,750 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (14,264 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,668 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (40,917 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (101,627 instructions, 0.10%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (101,654 instructions, 0.10%)ic_stable_structures::btreemap::node::Node<K>::load (11,109 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,295 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (29,372 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,730 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,715 instructions, 0.08%)stable_fs::runtime::structure_helpers::add_dir_entry (303,000 instructions, 0.29%)stable_fs::runtime::structure_helpers::create_path (624,485 instructions, 0.59%)stable_fs::runtime::dir::Dir::create_file (895,814 instructions, 0.84%)stable_fs::fs::FileSystem::create_file (898,852 instructions, 0.85%)stable_fs::fs::FileSystem::open_or_create (1,167,710 instructions, 1.10%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,219 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,000 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,160 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,306 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,225 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,371 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (18,054 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (55,200 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,605 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,751 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,532 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,313 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (337,247 instructions, 0.32%)stable_fs::runtime::structure_helpers::find_node (338,539 instructions, 0.32%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,219 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,000 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,160 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,306 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,225 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,371 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (18,054 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (55,200 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,605 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,751 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,749 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,532 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,313 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (337,247 instructions, 0.32%)stable_fs::runtime::structure_helpers::find_node (338,539 instructions, 0.32%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,246 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,027 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,187 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,333 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,252 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,398 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (18,081 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (55,227 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,632 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,778 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (17,559 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (54,340 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (11,136 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (13,160 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (14,840 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,899 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (42,500 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (60,678 instructions, 0.06%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (62,369 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (13,776 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (17,229 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (17,946 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (53,415 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (57,240 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (77,675 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (77,702 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::load (15,596 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,414 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,195 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,596 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (18,215 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,458 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,888 instructions, 0.05%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (113,070 instructions, 0.11%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (113,097 instructions, 0.11%)ic_stable_structures::btreemap::node::Node<K>::load (13,421 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (14,326 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,964 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (36,391 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (89,268 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (91,253 instructions, 0.09%)stable_fs::runtime::structure_helpers::add_dir_entry (343,078 instructions, 0.32%)stable_fs::runtime::structure_helpers::create_path (747,009 instructions, 0.70%)stable_fs::runtime::dir::Dir::create_file (1,088,164 instructions, 1.03%)stable_fs::fs::FileSystem::create_file (1,091,363 instructions, 1.03%)stable_fs::fs::FileSystem::open_or_create (1,430,047 instructions, 1.35%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,066 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (55,847 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,007 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,153 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,944 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (57,090 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,322 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,468 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,452 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,598 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,387 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,533 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (20,137 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,918 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (407,402 instructions, 0.38%)stable_fs::runtime::structure_helpers::find_node (408,667 instructions, 0.39%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,066 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (55,847 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,007 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,153 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,944 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (57,090 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,322 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,468 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,452 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,598 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,387 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,533 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (20,137 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,918 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (407,402 instructions, 0.38%)stable_fs::runtime::structure_helpers::find_node (408,667 instructions, 0.39%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,066 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (55,847 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,007 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,153 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,944 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (57,090 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,322 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,468 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,452 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,598 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (19,387 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,533 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (20,137 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (56,918 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (13,394 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (16,191 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,605 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (40,985 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (45,225 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (64,965 instructions, 0.06%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (66,656 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (15,569 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (21,180 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,342 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (56,986 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (61,198 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (82,805 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (82,832 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,000 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,781 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (20,453 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,342 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (56,259 instructions, 0.05%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (121,953 instructions, 0.11%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (121,980 instructions, 0.12%)ic_stable_structures::btreemap::node::Node<K>::load (14,951 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (16,655 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,605 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (41,449 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (95,799 instructions, 0.09%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (97,784 instructions, 0.09%)stable_fs::runtime::structure_helpers::add_dir_entry (366,208 instructions, 0.35%)stable_fs::runtime::structure_helpers::create_path (844,122 instructions, 0.80%)stable_fs::runtime::dir::Dir::create_file (1,255,405 instructions, 1.18%)stable_fs::fs::FileSystem::create_file (1,258,765 instructions, 1.19%)stable_fs::fs::FileSystem::open_or_create (1,667,577 instructions, 1.57%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,051 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (57,832 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (20,992 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,138 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,765 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,911 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,372 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,518 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,242 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,388 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,372 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,518 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,000 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (59,146 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,364 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,145 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (480,880 instructions, 0.45%)stable_fs::runtime::structure_helpers::find_node (482,145 instructions, 0.45%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,051 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (57,832 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (20,992 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,138 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,765 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,911 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,372 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,518 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,242 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,388 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,372 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,518 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,000 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (59,146 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,364 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,145 instructions, 0.05%)stable_fs::runtime::structure_helpers::find_node_with_index (480,880 instructions, 0.45%)stable_fs::runtime::structure_helpers::find_node (482,145 instructions, 0.45%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,051 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (57,832 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (20,992 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,138 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,765 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,911 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,372 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,518 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,242 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,388 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,372 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,518 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,000 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (59,146 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (21,364 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (58,145 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::load (14,951 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (18,520 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (14,246 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (46,043 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (50,605 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (71,902 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (73,593 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::load (17,462 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (24,111 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (17,226 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (64,050 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (68,584 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (92,084 instructions, 0.09%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (92,111 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,227 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,008 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (24,111 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (17,226 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (64,050 instructions, 0.06%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (131,266 instructions, 0.12%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (131,293 instructions, 0.12%)ic_stable_structures::btreemap::node::Node<K>::load (16,508 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (18,888 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (14,246 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (46,411 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (102,640 instructions, 0.10%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (104,625 instructions, 0.10%)stable_fs::runtime::structure_helpers::add_dir_entry (392,868 instructions, 0.37%)stable_fs::runtime::structure_helpers::create_path (951,199 instructions, 0.90%)stable_fs::runtime::dir::Dir::create_file (1,435,960 instructions, 1.35%)stable_fs::fs::FileSystem::create_file (1,439,481 instructions, 1.36%)stable_fs::fs::FileSystem::open_or_create (1,921,771 instructions, 1.81%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,971 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (59,752 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,912 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,058 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,685 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,831 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,292 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,438 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,162 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,308 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,357 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,503 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,985 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (61,131 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,227 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,373 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,284 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,065 instructions, 0.06%)stable_fs::runtime::structure_helpers::find_node_with_index (558,232 instructions, 0.53%)stable_fs::runtime::structure_helpers::find_node (559,497 instructions, 0.53%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,971 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (59,752 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,912 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,058 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,685 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,831 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,292 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,438 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,162 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,308 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,357 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,503 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,985 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (61,131 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,227 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,373 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,284 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,065 instructions, 0.06%)stable_fs::runtime::structure_helpers::find_node_with_index (558,232 instructions, 0.53%)stable_fs::runtime::structure_helpers::find_node (559,497 instructions, 0.53%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,971 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (59,752 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (22,912 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,058 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,685 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,831 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,292 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,438 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,162 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,308 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,357 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,503 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,985 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (61,131 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,227 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,373 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (23,284 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (60,065 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (16,508 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (20,753 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,887 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (51,005 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,889 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,743 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,434 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::load (19,355 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (27,076 instructions, 0.03%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (23,964 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (76,002 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (80,858 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (106,251 instructions, 0.10%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (106,278 instructions, 0.10%)ic_stable_structures::btreemap::node::Node<K>::load (21,764 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,663 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,444 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,764 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (27,769 instructions, 0.03%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (19,804 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (72,567 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (142,514 instructions, 0.13%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (142,541 instructions, 0.13%)ic_stable_structures::btreemap::node::Node<K>::load (18,065 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (21,151 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,887 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (51,403 instructions, 0.05%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,067 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (109,511 instructions, 0.10%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (111,496 instructions, 0.11%)stable_fs::runtime::structure_helpers::add_dir_entry (427,590 instructions, 0.40%)stable_fs::runtime::structure_helpers::create_path (1,070,116 instructions, 1.01%)stable_fs::runtime::dir::Dir::create_file (1,632,229 instructions, 1.54%)stable_fs::fs::FileSystem::create_file (1,635,911 instructions, 1.54%)stable_fs::fs::FileSystem::open_or_create (2,195,553 instructions, 2.07%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,402 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,183 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,343 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,489 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,116 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,262 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,788 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,934 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,723 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,869 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,593 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,739 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,481 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,627 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,723 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,869 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,658 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,804 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,408 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,189 instructions, 0.06%)stable_fs::runtime::structure_helpers::find_node_with_index (645,227 instructions, 0.61%)stable_fs::runtime::structure_helpers::find_node (646,492 instructions, 0.61%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,402 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,183 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,343 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,489 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,116 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,262 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,788 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,934 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,723 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,869 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,593 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,739 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,481 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,627 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,723 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,869 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,658 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,804 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,408 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,189 instructions, 0.06%)stable_fs::runtime::structure_helpers::find_node_with_index (645,227 instructions, 0.61%)stable_fs::runtime::structure_helpers::find_node (646,492 instructions, 0.61%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,402 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,183 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,343 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,489 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,116 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,262 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,788 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,934 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,723 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,869 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,593 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,739 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,481 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,627 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,723 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,869 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (25,658 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (23,154 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,864 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (62,804 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (26,408 instructions, 0.02%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (63,189 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (18,066 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,065 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (11,739 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::split (14,904 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (43,880 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (83,318 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,197 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (28,056 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (37,360 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (148,927 instructions, 0.14%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (150,618 instructions, 0.14%)ic_stable_structures::btreemap::node::Node<K>::load (21,765 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (30,734 instructions, 0.03%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (21,688 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (79,659 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (84,837 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (112,640 instructions, 0.11%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (112,667 instructions, 0.11%)ic_stable_structures::btreemap::node::Node<K>::load (23,658 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::get_helper (28,401 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,499 instructions, 0.03%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::get_direntry (65,182 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::load (23,658 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (30,106 instructions, 0.03%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (21,688 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (79,031 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_struct (12,727 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (22,789 instructions, 0.02%)<stable_fs::storage::types::DirEntry as ic_stable_structures::storable::Storable>::from_bytes (35,578 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (152,017 instructions, 0.14%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_direntry (152,044 instructions, 0.14%)ic_stable_structures::btreemap::node::Node<K>::save (20,996 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,416 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,523 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,162 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,134 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,188 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,173 instructions, 0.07%)stable_fs::runtime::structure_helpers::add_dir_entry (408,897 instructions, 0.39%)stable_fs::runtime::structure_helpers::create_path (1,208,604 instructions, 1.14%)stable_fs::runtime::dir::Dir::create_file (1,857,712 instructions, 1.75%)stable_fs::fs::FileSystem::create_file (1,861,555 instructions, 1.76%)stable_fs::fs::FileSystem::open_or_create (2,508,192 instructions, 2.36%)s..hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (73,144 instructions, 0.07%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (74,105 instructions, 0.07%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::grow (11,981 instructions, 0.01%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (11,281 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (20,980 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,338 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,445 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,597 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,582 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (195,016 instructions, 0.18%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (77,215 instructions, 0.07%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (78,699 instructions, 0.07%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (11,498 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (13,613 instructions, 0.01%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (17,849 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (21,006 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,444 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,551 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,703 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,688 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (194,293 instructions, 0.18%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (79,127 instructions, 0.07%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (80,611 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (16,923 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (18,851 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (24,993 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,430 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,537 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,689 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,674 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (203,335 instructions, 0.19%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (81,126 instructions, 0.08%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (82,610 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (22,348 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,572 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (32,686 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,332 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,778 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,763 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (187,116 instructions, 0.18%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (83,060 instructions, 0.08%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (84,544 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::save (27,773 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (30,218 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (40,239 instructions, 0.04%)ic_stable_structures::btreemap::node::Node<K>::save (25,199 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (28,949 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,423 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,575 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,560 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (239,013 instructions, 0.23%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::iter::IterInternal<K,V,M>::next_map (11,894 instructions, 0.01%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (84,994 instructions, 0.08%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (86,478 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (35,874 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,802 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,225 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (28,935 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,409 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,561 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,546 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (237,883 instructions, 0.22%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::iter::IterInternal<K,V,M>::next_map (13,828 instructions, 0.01%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (86,928 instructions, 0.08%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (88,412 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,530 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (55,365 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,251 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,011 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,485 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,637 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,622 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (247,456 instructions, 0.23%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)ic_stable_structures::btreemap::iter::IterInternal<K,V,M>::next_map (15,817 instructions, 0.01%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (88,917 instructions, 0.08%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (90,401 instructions, 0.09%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,251 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (63,048 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,277 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (28,957 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,431 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,583 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,568 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (257,074 instructions, 0.24%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)ic_stable_structures::btreemap::iter::IterInternal<K,V,M>::next_map (17,751 instructions, 0.02%)hashbrown::map::HashMap<K,V,S,A>::insert (65,464 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,727 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (90,915 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (92,399 instructions, 0.09%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (52,897 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (70,601 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,303 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,689 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,674 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (277,344 instructions, 0.26%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)ic_stable_structures::btreemap::iter::IterInternal<K,V,M>::next_map (19,685 instructions, 0.02%)hashbrown::map::HashMap<K,V,S,A>::insert (65,400 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add (68,663 instructions, 0.06%)stable_fs::storage::ptr_cache::PtrCache::add_range (92,785 instructions, 0.09%)<alloc::vec::Vec<T> as alloc::vec::spec_from_iter::SpecFromIter<T,I>>::from_iter (94,269 instructions, 0.09%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,441 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (58,553 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,164 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,049 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,523 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,454 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,426 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,675 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,660 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (276,150 instructions, 0.26%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (65,804 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (87,387 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (187,840 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::split (11,744 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (57,980 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (98,519 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,448 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,752 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (175,130 instructions, 0.17%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (275,663 instructions, 0.26%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,825 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,789 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,671 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (61,641 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (172,745 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,196 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (62,975 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (68,945 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (143,527 instructions, 0.14%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,774 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,749 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (54,719 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (161,228 instructions, 0.15%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (42,280 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (56,162 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (62,132 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (168,601 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,825 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,776 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,555 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (69,525 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (186,655 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (53,262 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (70,948 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (76,918 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (183,357 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (58,747 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (78,340 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (84,310 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (190,829 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,407 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,154 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (85,654 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (91,624 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (198,103 instructions, 0.19%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,209 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (53,902 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (71,588 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (77,558 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (189,006 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (59,303 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (78,896 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (84,866 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (185,783 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,574 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (86,074 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (92,044 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (192,921 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::split (11,744 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (64,125 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (106,155 instructions, 0.10%)ic_stable_structures::btreemap::node::Node<K>::load (11,376 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (35,963 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (178,581 instructions, 0.17%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (184,551 instructions, 0.17%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (259,517 instructions, 0.24%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,209 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::split (11,744 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (70,270 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (112,081 instructions, 0.11%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,768 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (185,654 instructions, 0.18%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (194,301 instructions, 0.18%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (311,805 instructions, 0.29%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,960 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,961 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (67,352 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (174,205 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,196 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,094 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (74,485 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (181,388 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,614 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,708 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (60,099 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (166,922 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,209 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,960 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,961 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (67,352 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (184,866 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,791 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,196 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,094 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (74,485 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (181,348 instructions, 0.17%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,304 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,398 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (59,789 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (160,010 instructions, 0.15%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (42,590 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (56,591 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (67,982 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (168,283 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,593 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,776 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,674 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (75,065 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (185,937 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (52,842 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (70,647 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (82,038 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (156,388 instructions, 0.15%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (53,902 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (71,707 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,098 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (189,375 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (59,143 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (78,855 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (90,246 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (196,483 instructions, 0.19%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,593 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,154 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (85,773 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (97,164 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (214,062 instructions, 0.20%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (53,902 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (71,707 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,098 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (189,305 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (59,143 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (78,855 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (90,246 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (196,533 instructions, 0.19%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,175 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,154 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (85,773 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (97,164 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (203,411 instructions, 0.19%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,414 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,521 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,742 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,727 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,328 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,601 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,822 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,807 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,408 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,032 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,454 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,561 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,782 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (74,767 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,368 instructions, 0.07%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (46,871 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (48,856 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,457 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,103 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,577 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,798 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,783 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,384 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,063 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,537 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,758 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,743 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,344 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,033 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,507 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,728 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,713 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,314 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,113 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,587 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,808 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,793 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,394 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,329 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,073 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,547 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (78,768 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (80,753 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,354 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,977 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,960 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,961 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (67,352 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (21,034 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,535 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,681 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,241 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,226 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (179,067 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (59,933 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (79,645 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (91,036 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (21,027 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,541 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,687 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,247 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,232 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (192,146 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,959 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (86,578 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (97,969 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,494 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,640 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,200 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,185 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (199,032 instructions, 0.19%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (10,812 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::split (11,744 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (76,415 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (118,973 instructions, 0.11%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (35,963 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (191,962 instructions, 0.18%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (203,353 instructions, 0.19%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,401 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,303 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,288 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (278,519 instructions, 0.26%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,977 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,490 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::split (11,744 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (82,560 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (125,113 instructions, 0.12%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,448 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (198,947 instructions, 0.19%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (213,016 instructions, 0.20%)ic_stable_structures::btreemap::node::Node<K>::save (25,331 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,196 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,709 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,269 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,254 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (330,759 instructions, 0.31%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (16,167 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,614 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,806 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (65,617 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,324 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,149 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,662 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,222 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,207 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (172,702 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (16,167 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,475 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,574 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (72,385 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,317 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,220 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,733 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,293 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,278 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (179,541 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (16,167 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (22,781 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::split (11,744 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (88,705 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::split_child (131,255 instructions, 0.12%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,448 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (205,302 instructions, 0.19%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (222,048 instructions, 0.21%)ic_stable_structures::btreemap::node::Node<K>::save (25,310 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,066 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,579 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,139 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,124 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (329,050 instructions, 0.31%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,977 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,614 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,768 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (68,192 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (25,303 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,139 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,652 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,212 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,197 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (185,878 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,559 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,475 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (55,536 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (74,960 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,092 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,605 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,523 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,495 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,165 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,150 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (181,988 instructions, 0.17%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,616 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,639 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,128 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (184,633 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (11,349 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (33,198 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (36,399 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,618 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (68,107 instructions, 0.06%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (169,625 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,361 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (42,430 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (56,556 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (76,045 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (188,134 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,196 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,219 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (82,708 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (158,289 instructions, 0.15%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,960 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (56,086 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (75,575 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (183,087 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,096 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,119 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,608 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (191,080 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,361 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (52,842 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (70,772 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (90,261 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (208,422 instructions, 0.20%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (41,960 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (56,086 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (75,575 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (182,978 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (48,096 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,054 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,478 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (190,961 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,943 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (52,842 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (70,707 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (90,131 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (197,574 instructions, 0.19%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,745 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (53,262 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (71,192 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (90,681 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (202,181 instructions, 0.19%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (13,256 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (38,623 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (42,120 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (56,246 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (75,735 instructions, 0.07%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (176,637 instructions, 0.17%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (17,060 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (13,680 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (12,276 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (49,473 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (53,902 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (71,832 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (91,321 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (192,183 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (58,498 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (78,335 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (97,824 instructions, 0.09%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (172,789 instructions, 0.16%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,745 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,616 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,639 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,128 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (200,635 instructions, 0.19%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (59,558 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (79,395 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (98,884 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (205,740 instructions, 0.19%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,154 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (85,898 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (105,387 instructions, 0.10%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (212,321 instructions, 0.20%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (15,153 instructions, 0.01%)core::cell::once::OnceCell<T>::try_init (11,970 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (10,912 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (44,048 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (47,616 instructions, 0.04%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (63,639 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (83,128 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (189,915 instructions, 0.18%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (16,745 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,967 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (15,390 instructions, 0.01%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (13,640 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (54,898 instructions, 0.05%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (59,558 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (79,330 instructions, 0.07%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (98,754 instructions, 0.09%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (216,232 instructions, 0.20%)<ic_stable_structures::memory_manager::VirtualMemory<M> as ic_stable_structures::Memory>::write (17,327 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (18,845 instructions, 0.02%)ic_stable_structures::btreemap::node::Node<K>::load (20,874 instructions, 0.02%)core::cell::once::OnceCell<T>::try_init (17,100 instructions, 0.02%)ic_stable_structures::btreemap::node::io::NodeWriter<M>::write (15,004 instructions, 0.01%)ic_stable_structures::btreemap::node::Node<K>::save (60,323 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (64,154 instructions, 0.06%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (85,833 instructions, 0.08%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (105,257 instructions, 0.10%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (212,084 instructions, 0.20%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,512 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,658 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,258 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,243 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,844 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,525 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,671 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,271 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,256 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,857 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (21,020 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (24,485 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (33,631 instructions, 0.03%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (73,231 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (75,216 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (79,817 instructions, 0.08%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,441 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (47,334 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (49,319 instructions, 0.05%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (53,920 instructions, 0.05%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,152 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,665 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,265 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,250 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,851 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,112 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,625 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,225 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,210 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,811 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,190 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,703 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,303 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,288 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,889 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,043 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,556 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,156 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,141 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,742 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,123 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,636 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,236 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,221 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,822 instructions, 0.08%)ic_stable_structures::btreemap::node::Node<K>::save (25,296 instructions, 0.02%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (29,083 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert_nonfull (39,596 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,563 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,535 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (79,196 instructions, 0.07%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::put_metadata (81,181 instructions, 0.08%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::write (85,782 instructions, 0.08%)stable_fs::fs::FileSystem::write_vec (91,935,623 instructions, 86.68%)stable_fs::fs::FileSystem::write_vecic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (15,554 instructions, 0.01%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (15,639 instructions, 0.01%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,058 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,143 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,058 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,143 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,058 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,143 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,058 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,143 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,813 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,898 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,813 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,898 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,813 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,898 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,813 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,898 instructions, 0.04%)compiler_builtins::mem::memset (11,313 instructions, 0.01%)memset (11,322 instructions, 0.01%)<&mut ciborium::de::Deserializer<R> as serde::de::Deserializer>::deserialize_map (16,517 instructions, 0.02%)<stable_fs::storage::types::Metadata as ic_stable_structures::storable::Storable>::from_bytes (28,395 instructions, 0.03%)ic_stable_structures::btreemap::BTreeMap<K,V,M>::insert (45,803 instructions, 0.04%)<stable_fs::storage::stable::StableStorage<M> as stable_fs::storage::Storage>::flush (45,888 instructions, 0.04%)stable_fs::fs::FileSystem::close (453,581 instructions, 0.43%)std::thread::local::LocalKey<T>::with (106,035,613 instructions, 99.97%)std::thread::local::LocalKey<T>::withfs_benchmarks_backend::__canister_method_store_buffer_in_1000b_segments_10_files::{{closure}} (106,062,599 instructions, 100.00%)fs_benchmarks_backend::__canister_method_store_buffer_in_1000b_segments_10_files::{{closure}}ic_cdk::futures::spawn (106,063,431 instructions, 100.00%)ic_cdk::futures::spawnall (106,063,453 instructions, 100%)canister_update store_buffer_in_1000b_segments_10_files (106,063,453 instructions, 100.00%)canister_update store_buffer_in_1000b_segments_10_files \ No newline at end of file